#include "cxx-qt-lib/qstring.h"
#include "cxx-qt-lib/qlist.h"
#include "cxx-qt-lib/qbytearray.h"
#include "cxx-qt-lib/qmap.h"
#include <QtCore/QObject>
#include "cxx-qt/connection.h"
#include "idescriptor_rust_codebase/src/service_manager.cxxqt.h"
#include "cxx-qt/thread.h"
#include <cstddef>
#include <cstdint>
#include <new>
#include <type_traits>
#include <utility>

#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wmissing-declarations"
#pragma GCC diagnostic ignored "-Wshadow"
#ifdef __clang__
#pragma clang diagnostic ignored "-Wdollar-in-identifier-extension"
#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
#endif // __clang__
#endif // __GNUC__

namespace rust {
inline namespace cxxbridge1 {
// #include "rust/cxx.h"

#ifndef CXXBRIDGE1_RUST_BOX
#define CXXBRIDGE1_RUST_BOX
template <typename T>
class Box final {
public:
  using element_type = T;
  using const_pointer =
      typename std::add_pointer<typename std::add_const<T>::type>::type;
  using pointer = typename std::add_pointer<T>::type;

  Box() = delete;
  Box(Box &&) noexcept;
  ~Box() noexcept;

  explicit Box(const T &);
  explicit Box(T &&);

  Box &operator=(Box &&) & noexcept;

  const T *operator->() const noexcept;
  const T &operator*() const noexcept;
  T *operator->() noexcept;
  T &operator*() noexcept;

  template <typename... Fields>
  static Box in_place(Fields &&...);

  void swap(Box &) noexcept;

  static Box from_raw(T *) noexcept;

  T *into_raw() noexcept;

  /* Deprecated */ using value_type = element_type;

private:
  class uninit;
  class allocation;
  Box(uninit) noexcept;
  void drop() noexcept;

  friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }

  T *ptr;
};

template <typename T>
class Box<T>::uninit {};

template <typename T>
class Box<T>::allocation {
  static T *alloc() noexcept;
  static void dealloc(T *) noexcept;

public:
  allocation() noexcept : ptr(alloc()) {}
  ~allocation() noexcept {
    if (this->ptr) {
      dealloc(this->ptr);
    }
  }
  T *ptr;
};

template <typename T>
Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
  other.ptr = nullptr;
}

template <typename T>
Box<T>::Box(const T &val) {
  allocation alloc;
  ::new (alloc.ptr) T(val);
  this->ptr = alloc.ptr;
  alloc.ptr = nullptr;
}

template <typename T>
Box<T>::Box(T &&val) {
  allocation alloc;
  ::new (alloc.ptr) T(std::move(val));
  this->ptr = alloc.ptr;
  alloc.ptr = nullptr;
}

template <typename T>
Box<T>::~Box() noexcept {
  if (this->ptr) {
    this->drop();
  }
}

template <typename T>
Box<T> &Box<T>::operator=(Box &&other) & noexcept {
  if (this->ptr) {
    this->drop();
  }
  this->ptr = other.ptr;
  other.ptr = nullptr;
  return *this;
}

template <typename T>
const T *Box<T>::operator->() const noexcept {
  return this->ptr;
}

template <typename T>
const T &Box<T>::operator*() const noexcept {
  return *this->ptr;
}

template <typename T>
T *Box<T>::operator->() noexcept {
  return this->ptr;
}

template <typename T>
T &Box<T>::operator*() noexcept {
  return *this->ptr;
}

template <typename T>
template <typename... Fields>
Box<T> Box<T>::in_place(Fields &&...fields) {
  allocation alloc;
  auto ptr = alloc.ptr;
  ::new (ptr) T{std::forward<Fields>(fields)...};
  alloc.ptr = nullptr;
  return from_raw(ptr);
}

template <typename T>
void Box<T>::swap(Box &rhs) noexcept {
  using std::swap;
  swap(this->ptr, rhs.ptr);
}

template <typename T>
Box<T> Box<T>::from_raw(T *raw) noexcept {
  Box box = uninit{};
  box.ptr = raw;
  return box;
}

template <typename T>
T *Box<T>::into_raw() noexcept {
  T *raw = this->ptr;
  this->ptr = nullptr;
  return raw;
}

template <typename T>
Box<T>::Box(uninit) noexcept {}
#endif // CXXBRIDGE1_RUST_BOX

#ifndef CXXBRIDGE1_RUST_FN
#define CXXBRIDGE1_RUST_FN
template <typename Signature>
class Fn;

template <typename Ret, typename... Args>
class Fn<Ret(Args...)> final {
public:
  Ret operator()(Args... args) const noexcept;
  Fn operator*() const noexcept;

private:
  Ret (*trampoline)(Args..., void *fn) noexcept;
  void *fn;
};

template <typename Ret, typename... Args>
Ret Fn<Ret(Args...)>::operator()(Args... args) const noexcept {
  return (*this->trampoline)(std::forward<Args>(args)..., this->fn);
}

template <typename Ret, typename... Args>
Fn<Ret(Args...)> Fn<Ret(Args...)>::operator*() const noexcept {
  return *this;
}
#endif // CXXBRIDGE1_RUST_FN

#ifndef CXXBRIDGE1_RUST_OPAQUE
#define CXXBRIDGE1_RUST_OPAQUE
class Opaque {
public:
  Opaque() = delete;
  Opaque(const Opaque &) = delete;
  ~Opaque() = delete;
};
#endif // CXXBRIDGE1_RUST_OPAQUE

#ifndef CXXBRIDGE1_IS_COMPLETE
#define CXXBRIDGE1_IS_COMPLETE
namespace detail {
namespace {
template <typename T, typename = std::size_t>
struct is_complete : std::false_type {};
template <typename T>
struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
} // namespace
} // namespace detail
#endif // CXXBRIDGE1_IS_COMPLETE

#ifndef CXXBRIDGE1_LAYOUT
#define CXXBRIDGE1_LAYOUT
class layout {
  template <typename T>
  friend std::size_t size_of();
  template <typename T>
  friend std::size_t align_of();
  template <typename T>
  static typename std::enable_if<std::is_base_of<Opaque, T>::value,
                                 std::size_t>::type
  do_size_of() {
    return T::layout::size();
  }
  template <typename T>
  static typename std::enable_if<!std::is_base_of<Opaque, T>::value,
                                 std::size_t>::type
  do_size_of() {
    return sizeof(T);
  }
  template <typename T>
  static
      typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type
      size_of() {
    return do_size_of<T>();
  }
  template <typename T>
  static typename std::enable_if<std::is_base_of<Opaque, T>::value,
                                 std::size_t>::type
  do_align_of() {
    return T::layout::align();
  }
  template <typename T>
  static typename std::enable_if<!std::is_base_of<Opaque, T>::value,
                                 std::size_t>::type
  do_align_of() {
    return alignof(T);
  }
  template <typename T>
  static
      typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type
      align_of() {
    return do_align_of<T>();
  }
};

template <typename T>
std::size_t size_of() {
  return layout::size_of<T>();
}

template <typename T>
std::size_t align_of() {
  return layout::align_of<T>();
}
#endif // CXXBRIDGE1_LAYOUT

#ifndef CXXBRIDGE1_RELOCATABLE
#define CXXBRIDGE1_RELOCATABLE
namespace detail {
template <typename... Ts>
struct make_void {
  using type = void;
};

template <typename... Ts>
using void_t = typename make_void<Ts...>::type;

template <typename Void, template <typename...> class, typename...>
struct detect : std::false_type {};
template <template <typename...> class T, typename... A>
struct detect<void_t<T<A...>>, T, A...> : std::true_type {};

template <template <typename...> class T, typename... A>
using is_detected = detect<void, T, A...>;

template <typename T>
using detect_IsRelocatable = typename T::IsRelocatable;

template <typename T>
struct get_IsRelocatable
    : std::is_same<typename T::IsRelocatable, std::true_type> {};
} // namespace detail

template <typename T>
struct IsRelocatable
    : std::conditional<
          detail::is_detected<detail::detect_IsRelocatable, T>::value,
          detail::get_IsRelocatable<T>,
          std::integral_constant<
              bool, std::is_trivially_move_constructible<T>::value &&
                        std::is_trivially_destructible<T>::value>>::type {};
#endif // CXXBRIDGE1_RELOCATABLE

namespace detail {
template <typename T, typename = void *>
struct operator_new {
  void *operator()(::std::size_t sz) { return ::operator new(sz); }
};

template <typename T>
struct operator_new<T, decltype(T::operator new(sizeof(T)))> {
  void *operator()(::std::size_t sz) { return T::operator new(sz); }
};
} // namespace detail

template <typename T>
union ManuallyDrop {
  T value;
  ManuallyDrop(T &&value) : value(::std::move(value)) {}
  ~ManuallyDrop() {}
};

template <typename T>
union MaybeUninit {
  T value;
  void *operator new(::std::size_t sz) { return detail::operator_new<T>{}(sz); }
  MaybeUninit() {}
  ~MaybeUninit() {}
};
} // namespace cxxbridge1
} // namespace rust

#if __cplusplus >= 201402L
#define CXX_DEFAULT_VALUE(value) = value
#else
#define CXX_DEFAULT_VALUE(value)
#endif

namespace CXX {
  using ServiceManager = ::CXX::ServiceManager;
  struct RServiceManager;
  namespace cxx_qt_ServiceManager {
    struct ServiceManagerCxxQtThreadQueuedFn;
    struct CxxQtConstructorArguments0;
    struct CxxQtConstructorBaseArguments0;
    struct CxxQtConstructorNewArguments0;
    struct CxxQtConstructorInitializeArguments0;
  }
}

namespace CXX {
#ifndef CXXBRIDGE1_STRUCT_CXX$RServiceManager
#define CXXBRIDGE1_STRUCT_CXX$RServiceManager
struct RServiceManager final : public ::rust::Opaque {
  ~RServiceManager() = delete;

private:
  friend ::rust::layout;
  struct layout {
    static ::std::size_t size() noexcept;
    static ::std::size_t align() noexcept;
  };
};
#endif // CXXBRIDGE1_STRUCT_CXX$RServiceManager

namespace cxx_qt_ServiceManager {
#ifndef CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$ServiceManagerCxxQtThreadQueuedFn
#define CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$ServiceManagerCxxQtThreadQueuedFn
struct ServiceManagerCxxQtThreadQueuedFn final : public ::rust::Opaque {
  ~ServiceManagerCxxQtThreadQueuedFn() = delete;

private:
  friend ::rust::layout;
  struct layout {
    static ::std::size_t size() noexcept;
    static ::std::size_t align() noexcept;
  };
};
#endif // CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$ServiceManagerCxxQtThreadQueuedFn

#ifndef CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$CxxQtConstructorBaseArguments0
#define CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$CxxQtConstructorBaseArguments0
struct CxxQtConstructorBaseArguments0 final {
  ::std::int8_t not_empty CXX_DEFAULT_VALUE(0);

  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$CxxQtConstructorBaseArguments0

#ifndef CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$CxxQtConstructorNewArguments0
#define CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$CxxQtConstructorNewArguments0
struct CxxQtConstructorNewArguments0 final {
  ::QString arg0;
  ::std::uint32_t arg1 CXX_DEFAULT_VALUE(0);

  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$CxxQtConstructorNewArguments0

#ifndef CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$CxxQtConstructorInitializeArguments0
#define CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$CxxQtConstructorInitializeArguments0
struct CxxQtConstructorInitializeArguments0 final {
  ::std::int8_t not_empty CXX_DEFAULT_VALUE(0);

  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$CxxQtConstructorInitializeArguments0

#ifndef CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$CxxQtConstructorArguments0
#define CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$CxxQtConstructorArguments0
struct CxxQtConstructorArguments0 final {
  ::CXX::cxx_qt_ServiceManager::CxxQtConstructorBaseArguments0 base;
  ::CXX::cxx_qt_ServiceManager::CxxQtConstructorNewArguments0 new_;
  ::CXX::cxx_qt_ServiceManager::CxxQtConstructorInitializeArguments0 initialize;

  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_CXX$cxx_qt_ServiceManager$CxxQtConstructorArguments0
} // namespace cxx_qt_ServiceManager
} // namespace CXX

static_assert(
    ::rust::IsRelocatable<::QString>::value,
    "type QString should be trivially move constructible and trivially destructible in C++ to be used as a field of `CxxQtConstructorNewArgumentsServiceManager0` or argument of `fetch_app_icon`, `cable_info_retrieved`, `call_ServiceManager_signal_handler_cable_info_retrieved` in Rust");
static_assert(
    ::rust::IsRelocatable<::QByteArray>::value,
    "type QByteArray should be trivially move constructible and trivially destructible in C++ to be used as an argument of `mounted_image_retrieved`, `call_ServiceManager_signal_handler_mounted_image_retrieved`, `app_icon_loaded` in Rust");
static_assert(
    ::rust::IsRelocatable<::QMap_QString_QVariant>::value,
    "type QMap_QString_QVariant should be trivially move constructible and trivially destructible in C++ to be used as an argument of `mobilegestalt_info_retrieved`, `call_ServiceManager_signal_handler_mobilegestalt_info_retrieved` in Rust");
static_assert(
    ::rust::IsRelocatable<::Qt::ConnectionType>::value,
    "type Qt::ConnectionType should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_cable_info_retrieved`, `ServiceManager_connect_mobilegestalt_info_retrieved`, `ServiceManager_connect_dev_image_mounted` in Rust");
static_assert(
    ::rust::IsRelocatable<::rust::cxxqt1::QMetaObjectConnection>::value,
    "type rust::cxxqt1::QMetaObjectConnection should be trivially move constructible and trivially destructible in C++ to be used as a return value of `ServiceManager_connect_cable_info_retrieved`, `ServiceManager_connect_mobilegestalt_info_retrieved`, `ServiceManager_connect_dev_image_mounted` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlercable_info_retrieved>::value,
    "type CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlercable_info_retrieved should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_cable_info_retrieved`, `drop_ServiceManager_signal_handler_cable_info_retrieved` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermobilegestalt_info_retrieved>::value,
    "type CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermobilegestalt_info_retrieved should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_mobilegestalt_info_retrieved`, `drop_ServiceManager_signal_handler_mobilegestalt_info_retrieved` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdev_image_mounted>::value,
    "type CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdev_image_mounted should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_dev_image_mounted`, `drop_ServiceManager_signal_handler_dev_image_mounted` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdeveloper_mode_option_revealed>::value,
    "type CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdeveloper_mode_option_revealed should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_developer_mode_option_revealed`, `drop_ServiceManager_signal_handler_developer_mode_option_revealed` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermounted_image_retrieved>::value,
    "type CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermounted_image_retrieved should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_mounted_image_retrieved`, `drop_ServiceManager_signal_handler_mounted_image_retrieved` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstalled_apps_retrieved>::value,
    "type CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstalled_apps_retrieved should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_installed_apps_retrieved`, `drop_ServiceManager_signal_handler_installed_apps_retrieved` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerapp_icon_loaded>::value,
    "type CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerapp_icon_loaded should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_app_icon_loaded`, `drop_ServiceManager_signal_handler_app_icon_loaded` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerbattery_info_updated>::value,
    "type CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerbattery_info_updated should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_battery_info_updated`, `drop_ServiceManager_signal_handler_battery_info_updated` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdisk_usage_retrieved>::value,
    "type CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdisk_usage_retrieved should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_disk_usage_retrieved`, `drop_ServiceManager_signal_handler_disk_usage_retrieved` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_init>::value,
    "type CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_init should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_install_ipa_init`, `drop_ServiceManager_signal_handler_install_ipa_init` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_progress>::value,
    "type CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_progress should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_install_ipa_progress`, `drop_ServiceManager_signal_handler_install_ipa_progress` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerenable_wifi_connections_result>::value,
    "type CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerenable_wifi_connections_result should be trivially move constructible and trivially destructible in C++ to be used as an argument of `ServiceManager_connect_enable_wifi_connections_result`, `drop_ServiceManager_signal_handler_enable_wifi_connections_result` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::ServiceManagerCxxQtThread>::value,
    "type CXX::ServiceManagerCxxQtThread should be trivially move constructible and trivially destructible in C++ to be used as a return value of `cxx_qt_ffi_ServiceManager_qtThread`, `cxx_qt_ffi_ServiceManager_cxxQtThreadClone` in Rust");

namespace CXX {
extern "C" {
::std::size_t CXX$cxxbridge1$194$RServiceManager$operator$sizeof() noexcept;
::std::size_t CXX$cxxbridge1$194$RServiceManager$operator$alignof() noexcept;

void CXX$cxxbridge1$194$ServiceManager$set_udid(::CXX::ServiceManager &self, ::QString const &udid) noexcept;

void CXX$cxxbridge1$194$ServiceManager$get_cable_info(::CXX::ServiceManager const &self) noexcept;

void CXX$cxxbridge1$194$ServiceManager$reveal_developer_mode_option_in_ui(::CXX::ServiceManager const &self) noexcept;

void CXX$cxxbridge1$194$ServiceManager$query_mobilegestalt(::CXX::ServiceManager const &self, ::QList_QString const &keys) noexcept;

void CXX$cxxbridge1$194$ServiceManager$mount_dev_image(::CXX::ServiceManager const &self, ::QString const &image_path, ::QString const &sig) noexcept;

void CXX$cxxbridge1$194$ServiceManager$get_mounted_image(::CXX::ServiceManager const &self) noexcept;

void CXX$cxxbridge1$194$ServiceManager$fetch_installed_apps(::CXX::ServiceManager const &self) noexcept;

::std::int32_t CXX$cxxbridge1$194$ServiceManager$set_location(::CXX::ServiceManager const &self, ::QString const &latitude, ::QString const &longitude) noexcept;

void CXX$cxxbridge1$194$ServiceManager$fetch_app_icon(::CXX::ServiceManager const &self, ::QString *bundle_id) noexcept;

void CXX$cxxbridge1$194$ServiceManager$fetch_disk_usage(::CXX::ServiceManager const &self, bool skip_gallery_usage) noexcept;

bool CXX$cxxbridge1$194$ServiceManager$restart(::CXX::ServiceManager const &self) noexcept;

bool CXX$cxxbridge1$194$ServiceManager$shutdown(::CXX::ServiceManager const &self) noexcept;

bool CXX$cxxbridge1$194$ServiceManager$enter_recovery_mode(::CXX::ServiceManager const &self) noexcept;

void CXX$cxxbridge1$194$ServiceManager$install_ipa(::CXX::ServiceManager const &self, ::QString const &ipa_path) noexcept;

void CXX$cxxbridge1$194$ServiceManager$enable_wifi_connections(::CXX::ServiceManager const &self) noexcept;

void CXX$cxxbridge1$194$ServiceManager$cable_info_retrieved(::CXX::ServiceManager &self, ::QString *info) noexcept {
  void (::CXX::ServiceManager::*cable_info_retrieved$)(::QString) = &::CXX::ServiceManager::cable_info_retrieved;
  (self.*cable_info_retrieved$)(::std::move(*info));
}
} // extern "C"

namespace rust {
namespace cxxqtgen1 {
extern "C" {
void CXX$rust$cxxqtgen1$cxxbridge1$194$ServiceManager_connect_cable_info_retrieved(::CXX::ServiceManager &self_value, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlercable_info_retrieved *signal_handler, ::Qt::ConnectionType *conn_type, ::rust::cxxqt1::QMetaObjectConnection *return$) noexcept {
  ::rust::cxxqt1::QMetaObjectConnection (*ServiceManager_connect_cable_info_retrieved$)(::CXX::ServiceManager &, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlercable_info_retrieved, ::Qt::ConnectionType) = ::CXX::rust::cxxqtgen1::ServiceManager_cable_info_retrievedConnect;
  new (return$) ::rust::cxxqt1::QMetaObjectConnection(ServiceManager_connect_cable_info_retrieved$(self_value, ::std::move(*signal_handler), ::std::move(*conn_type)));
}

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_cable_info_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlercable_info_retrieved *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_cable_info_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlercable_info_retrieved &handler, ::CXX::ServiceManager &self_value, ::QString *info) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$ServiceManager$mobilegestalt_info_retrieved(::CXX::ServiceManager &self, ::QMap_QString_QVariant *info) noexcept {
  void (::CXX::ServiceManager::*mobilegestalt_info_retrieved$)(::QMap_QString_QVariant) = &::CXX::ServiceManager::mobilegestalt_info_retrieved;
  (self.*mobilegestalt_info_retrieved$)(::std::move(*info));
}
} // extern "C"

namespace rust {
namespace cxxqtgen1 {
extern "C" {
void CXX$rust$cxxqtgen1$cxxbridge1$194$ServiceManager_connect_mobilegestalt_info_retrieved(::CXX::ServiceManager &self_value, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermobilegestalt_info_retrieved *signal_handler, ::Qt::ConnectionType *conn_type, ::rust::cxxqt1::QMetaObjectConnection *return$) noexcept {
  ::rust::cxxqt1::QMetaObjectConnection (*ServiceManager_connect_mobilegestalt_info_retrieved$)(::CXX::ServiceManager &, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermobilegestalt_info_retrieved, ::Qt::ConnectionType) = ::CXX::rust::cxxqtgen1::ServiceManager_mobilegestalt_info_retrievedConnect;
  new (return$) ::rust::cxxqt1::QMetaObjectConnection(ServiceManager_connect_mobilegestalt_info_retrieved$(self_value, ::std::move(*signal_handler), ::std::move(*conn_type)));
}

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_mobilegestalt_info_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermobilegestalt_info_retrieved *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_mobilegestalt_info_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermobilegestalt_info_retrieved &handler, ::CXX::ServiceManager &self_value, ::QMap_QString_QVariant *info) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$ServiceManager$dev_image_mounted(::CXX::ServiceManager &self, bool success, bool is_locked) noexcept {
  void (::CXX::ServiceManager::*dev_image_mounted$)(bool, bool) = &::CXX::ServiceManager::dev_image_mounted;
  (self.*dev_image_mounted$)(success, is_locked);
}
} // extern "C"

namespace rust {
namespace cxxqtgen1 {
extern "C" {
void CXX$rust$cxxqtgen1$cxxbridge1$194$ServiceManager_connect_dev_image_mounted(::CXX::ServiceManager &self_value, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdev_image_mounted *signal_handler, ::Qt::ConnectionType *conn_type, ::rust::cxxqt1::QMetaObjectConnection *return$) noexcept {
  ::rust::cxxqt1::QMetaObjectConnection (*ServiceManager_connect_dev_image_mounted$)(::CXX::ServiceManager &, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdev_image_mounted, ::Qt::ConnectionType) = ::CXX::rust::cxxqtgen1::ServiceManager_dev_image_mountedConnect;
  new (return$) ::rust::cxxqt1::QMetaObjectConnection(ServiceManager_connect_dev_image_mounted$(self_value, ::std::move(*signal_handler), ::std::move(*conn_type)));
}

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_dev_image_mounted(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdev_image_mounted *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_dev_image_mounted(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdev_image_mounted &handler, ::CXX::ServiceManager &self_value, bool success, bool is_locked) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$ServiceManager$developer_mode_option_revealed(::CXX::ServiceManager &self, bool success) noexcept {
  void (::CXX::ServiceManager::*developer_mode_option_revealed$)(bool) = &::CXX::ServiceManager::developer_mode_option_revealed;
  (self.*developer_mode_option_revealed$)(success);
}
} // extern "C"

namespace rust {
namespace cxxqtgen1 {
extern "C" {
void CXX$rust$cxxqtgen1$cxxbridge1$194$ServiceManager_connect_developer_mode_option_revealed(::CXX::ServiceManager &self_value, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdeveloper_mode_option_revealed *signal_handler, ::Qt::ConnectionType *conn_type, ::rust::cxxqt1::QMetaObjectConnection *return$) noexcept {
  ::rust::cxxqt1::QMetaObjectConnection (*ServiceManager_connect_developer_mode_option_revealed$)(::CXX::ServiceManager &, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdeveloper_mode_option_revealed, ::Qt::ConnectionType) = ::CXX::rust::cxxqtgen1::ServiceManager_developer_mode_option_revealedConnect;
  new (return$) ::rust::cxxqt1::QMetaObjectConnection(ServiceManager_connect_developer_mode_option_revealed$(self_value, ::std::move(*signal_handler), ::std::move(*conn_type)));
}

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_developer_mode_option_revealed(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdeveloper_mode_option_revealed *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_developer_mode_option_revealed(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdeveloper_mode_option_revealed &handler, ::CXX::ServiceManager &self_value, bool success) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$ServiceManager$mounted_image_retrieved(::CXX::ServiceManager &self, bool success, bool is_locked, ::QByteArray *sig, ::std::uint64_t sig_length) noexcept {
  void (::CXX::ServiceManager::*mounted_image_retrieved$)(bool, bool, ::QByteArray, ::std::uint64_t) = &::CXX::ServiceManager::mounted_image_retrieved;
  (self.*mounted_image_retrieved$)(success, is_locked, ::std::move(*sig), sig_length);
}
} // extern "C"

namespace rust {
namespace cxxqtgen1 {
extern "C" {
void CXX$rust$cxxqtgen1$cxxbridge1$194$ServiceManager_connect_mounted_image_retrieved(::CXX::ServiceManager &self_value, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermounted_image_retrieved *signal_handler, ::Qt::ConnectionType *conn_type, ::rust::cxxqt1::QMetaObjectConnection *return$) noexcept {
  ::rust::cxxqt1::QMetaObjectConnection (*ServiceManager_connect_mounted_image_retrieved$)(::CXX::ServiceManager &, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermounted_image_retrieved, ::Qt::ConnectionType) = ::CXX::rust::cxxqtgen1::ServiceManager_mounted_image_retrievedConnect;
  new (return$) ::rust::cxxqt1::QMetaObjectConnection(ServiceManager_connect_mounted_image_retrieved$(self_value, ::std::move(*signal_handler), ::std::move(*conn_type)));
}

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_mounted_image_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermounted_image_retrieved *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_mounted_image_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermounted_image_retrieved &handler, ::CXX::ServiceManager &self_value, bool success, bool is_locked, ::QByteArray *sig, ::std::uint64_t sig_length) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$ServiceManager$installed_apps_retrieved(::CXX::ServiceManager &self, ::QMap_QString_QVariant const &apps) noexcept {
  void (::CXX::ServiceManager::*installed_apps_retrieved$)(::QMap_QString_QVariant const &) = &::CXX::ServiceManager::installed_apps_retrieved;
  (self.*installed_apps_retrieved$)(apps);
}
} // extern "C"

namespace rust {
namespace cxxqtgen1 {
extern "C" {
void CXX$rust$cxxqtgen1$cxxbridge1$194$ServiceManager_connect_installed_apps_retrieved(::CXX::ServiceManager &self_value, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstalled_apps_retrieved *signal_handler, ::Qt::ConnectionType *conn_type, ::rust::cxxqt1::QMetaObjectConnection *return$) noexcept {
  ::rust::cxxqt1::QMetaObjectConnection (*ServiceManager_connect_installed_apps_retrieved$)(::CXX::ServiceManager &, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstalled_apps_retrieved, ::Qt::ConnectionType) = ::CXX::rust::cxxqtgen1::ServiceManager_installed_apps_retrievedConnect;
  new (return$) ::rust::cxxqt1::QMetaObjectConnection(ServiceManager_connect_installed_apps_retrieved$(self_value, ::std::move(*signal_handler), ::std::move(*conn_type)));
}

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_installed_apps_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstalled_apps_retrieved *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_installed_apps_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstalled_apps_retrieved &handler, ::CXX::ServiceManager &self_value, ::QMap_QString_QVariant const &apps) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$ServiceManager$app_icon_loaded(::CXX::ServiceManager &self, ::QString *bundle_id, ::QByteArray *icon_data) noexcept {
  void (::CXX::ServiceManager::*app_icon_loaded$)(::QString, ::QByteArray) = &::CXX::ServiceManager::app_icon_loaded;
  (self.*app_icon_loaded$)(::std::move(*bundle_id), ::std::move(*icon_data));
}
} // extern "C"

namespace rust {
namespace cxxqtgen1 {
extern "C" {
void CXX$rust$cxxqtgen1$cxxbridge1$194$ServiceManager_connect_app_icon_loaded(::CXX::ServiceManager &self_value, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerapp_icon_loaded *signal_handler, ::Qt::ConnectionType *conn_type, ::rust::cxxqt1::QMetaObjectConnection *return$) noexcept {
  ::rust::cxxqt1::QMetaObjectConnection (*ServiceManager_connect_app_icon_loaded$)(::CXX::ServiceManager &, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerapp_icon_loaded, ::Qt::ConnectionType) = ::CXX::rust::cxxqtgen1::ServiceManager_app_icon_loadedConnect;
  new (return$) ::rust::cxxqt1::QMetaObjectConnection(ServiceManager_connect_app_icon_loaded$(self_value, ::std::move(*signal_handler), ::std::move(*conn_type)));
}

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_app_icon_loaded(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerapp_icon_loaded *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_app_icon_loaded(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerapp_icon_loaded &handler, ::CXX::ServiceManager &self_value, ::QString *bundle_id, ::QByteArray *icon_data) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$ServiceManager$battery_info_updated(::CXX::ServiceManager &self, ::QString const &info) noexcept {
  void (::CXX::ServiceManager::*battery_info_updated$)(::QString const &) = &::CXX::ServiceManager::battery_info_updated;
  (self.*battery_info_updated$)(info);
}
} // extern "C"

namespace rust {
namespace cxxqtgen1 {
extern "C" {
void CXX$rust$cxxqtgen1$cxxbridge1$194$ServiceManager_connect_battery_info_updated(::CXX::ServiceManager &self_value, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerbattery_info_updated *signal_handler, ::Qt::ConnectionType *conn_type, ::rust::cxxqt1::QMetaObjectConnection *return$) noexcept {
  ::rust::cxxqt1::QMetaObjectConnection (*ServiceManager_connect_battery_info_updated$)(::CXX::ServiceManager &, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerbattery_info_updated, ::Qt::ConnectionType) = ::CXX::rust::cxxqtgen1::ServiceManager_battery_info_updatedConnect;
  new (return$) ::rust::cxxqt1::QMetaObjectConnection(ServiceManager_connect_battery_info_updated$(self_value, ::std::move(*signal_handler), ::std::move(*conn_type)));
}

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_battery_info_updated(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerbattery_info_updated *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_battery_info_updated(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerbattery_info_updated &handler, ::CXX::ServiceManager &self_value, ::QString const &info) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$ServiceManager$disk_usage_retrieved(::CXX::ServiceManager &self, bool success, ::std::uint64_t apps_usage, ::std::uint64_t gallery_usage) noexcept {
  void (::CXX::ServiceManager::*disk_usage_retrieved$)(bool, ::std::uint64_t, ::std::uint64_t) = &::CXX::ServiceManager::disk_usage_retrieved;
  (self.*disk_usage_retrieved$)(success, apps_usage, gallery_usage);
}
} // extern "C"

namespace rust {
namespace cxxqtgen1 {
extern "C" {
void CXX$rust$cxxqtgen1$cxxbridge1$194$ServiceManager_connect_disk_usage_retrieved(::CXX::ServiceManager &self_value, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdisk_usage_retrieved *signal_handler, ::Qt::ConnectionType *conn_type, ::rust::cxxqt1::QMetaObjectConnection *return$) noexcept {
  ::rust::cxxqt1::QMetaObjectConnection (*ServiceManager_connect_disk_usage_retrieved$)(::CXX::ServiceManager &, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdisk_usage_retrieved, ::Qt::ConnectionType) = ::CXX::rust::cxxqtgen1::ServiceManager_disk_usage_retrievedConnect;
  new (return$) ::rust::cxxqt1::QMetaObjectConnection(ServiceManager_connect_disk_usage_retrieved$(self_value, ::std::move(*signal_handler), ::std::move(*conn_type)));
}

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_disk_usage_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdisk_usage_retrieved *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_disk_usage_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdisk_usage_retrieved &handler, ::CXX::ServiceManager &self_value, bool success, ::std::uint64_t apps_usage, ::std::uint64_t gallery_usage) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$ServiceManager$install_ipa_init(::CXX::ServiceManager &self, bool started, ::QString *state) noexcept {
  void (::CXX::ServiceManager::*install_ipa_init$)(bool, ::QString) = &::CXX::ServiceManager::install_ipa_init;
  (self.*install_ipa_init$)(started, ::std::move(*state));
}
} // extern "C"

namespace rust {
namespace cxxqtgen1 {
extern "C" {
void CXX$rust$cxxqtgen1$cxxbridge1$194$ServiceManager_connect_install_ipa_init(::CXX::ServiceManager &self_value, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_init *signal_handler, ::Qt::ConnectionType *conn_type, ::rust::cxxqt1::QMetaObjectConnection *return$) noexcept {
  ::rust::cxxqt1::QMetaObjectConnection (*ServiceManager_connect_install_ipa_init$)(::CXX::ServiceManager &, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_init, ::Qt::ConnectionType) = ::CXX::rust::cxxqtgen1::ServiceManager_install_ipa_initConnect;
  new (return$) ::rust::cxxqt1::QMetaObjectConnection(ServiceManager_connect_install_ipa_init$(self_value, ::std::move(*signal_handler), ::std::move(*conn_type)));
}

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_install_ipa_init(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_init *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_install_ipa_init(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_init &handler, ::CXX::ServiceManager &self_value, bool started, ::QString *state) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$ServiceManager$install_ipa_progress(::CXX::ServiceManager &self, double progress, ::QString *state) noexcept {
  void (::CXX::ServiceManager::*install_ipa_progress$)(double, ::QString) = &::CXX::ServiceManager::install_ipa_progress;
  (self.*install_ipa_progress$)(progress, ::std::move(*state));
}
} // extern "C"

namespace rust {
namespace cxxqtgen1 {
extern "C" {
void CXX$rust$cxxqtgen1$cxxbridge1$194$ServiceManager_connect_install_ipa_progress(::CXX::ServiceManager &self_value, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_progress *signal_handler, ::Qt::ConnectionType *conn_type, ::rust::cxxqt1::QMetaObjectConnection *return$) noexcept {
  ::rust::cxxqt1::QMetaObjectConnection (*ServiceManager_connect_install_ipa_progress$)(::CXX::ServiceManager &, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_progress, ::Qt::ConnectionType) = ::CXX::rust::cxxqtgen1::ServiceManager_install_ipa_progressConnect;
  new (return$) ::rust::cxxqt1::QMetaObjectConnection(ServiceManager_connect_install_ipa_progress$(self_value, ::std::move(*signal_handler), ::std::move(*conn_type)));
}

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_install_ipa_progress(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_progress *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_install_ipa_progress(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_progress &handler, ::CXX::ServiceManager &self_value, double progress, ::QString *state) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$ServiceManager$enable_wifi_connections_result(::CXX::ServiceManager &self, bool success) noexcept {
  void (::CXX::ServiceManager::*enable_wifi_connections_result$)(bool) = &::CXX::ServiceManager::enable_wifi_connections_result;
  (self.*enable_wifi_connections_result$)(success);
}
} // extern "C"

namespace rust {
namespace cxxqtgen1 {
extern "C" {
void CXX$rust$cxxqtgen1$cxxbridge1$194$ServiceManager_connect_enable_wifi_connections_result(::CXX::ServiceManager &self_value, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerenable_wifi_connections_result *signal_handler, ::Qt::ConnectionType *conn_type, ::rust::cxxqt1::QMetaObjectConnection *return$) noexcept {
  ::rust::cxxqt1::QMetaObjectConnection (*ServiceManager_connect_enable_wifi_connections_result$)(::CXX::ServiceManager &, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerenable_wifi_connections_result, ::Qt::ConnectionType) = ::CXX::rust::cxxqtgen1::ServiceManager_enable_wifi_connections_resultConnect;
  new (return$) ::rust::cxxqt1::QMetaObjectConnection(ServiceManager_connect_enable_wifi_connections_result$(self_value, ::std::move(*signal_handler), ::std::move(*conn_type)));
}

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_enable_wifi_connections_result(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerenable_wifi_connections_result *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_enable_wifi_connections_result(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerenable_wifi_connections_result &handler, ::CXX::ServiceManager &self_value, bool success) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust
} // namespace CXX

namespace rust {
namespace cxxqt1 {
extern "C" {
void rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_ServiceManager_qtThread(::CXX::ServiceManager const &qobject, ::CXX::ServiceManagerCxxQtThread *return$) noexcept {
  ::CXX::ServiceManagerCxxQtThread (*cxx_qt_ffi_ServiceManager_qtThread$)(::CXX::ServiceManager const &) = ::rust::cxxqt1::qtThread;
  new (return$) ::CXX::ServiceManagerCxxQtThread(cxx_qt_ffi_ServiceManager_qtThread$(qobject));
}

::std::uint8_t rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_ServiceManager_cxxQtThreadQueue(::CXX::ServiceManagerCxxQtThread const &cxx_qt_thread, ::rust::Fn<void(::CXX::ServiceManager &, ::rust::Box<::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn>)> func, ::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn *arg) noexcept {
  ::std::uint8_t (*cxx_qt_ffi_ServiceManager_cxxQtThreadQueue$)(::CXX::ServiceManagerCxxQtThread const &, ::rust::Fn<void(::CXX::ServiceManager &, ::rust::Box<::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn>)>, ::rust::Box<::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn>) = ::rust::cxxqt1::cxxQtThreadQueue;
  return cxx_qt_ffi_ServiceManager_cxxQtThreadQueue$(cxx_qt_thread, func, ::rust::Box<::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn>::from_raw(arg));
}

void rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_ServiceManager_cxxQtThreadQueue$func$1(::CXX::ServiceManager &arg0, ::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn *arg1, void *) noexcept;

void rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_ServiceManager_cxxQtThreadQueue$func$0(::CXX::ServiceManager &arg0, ::rust::Box<::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn> arg1, void *extern$) noexcept {
  rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_ServiceManager_cxxQtThreadQueue$func$1(arg0, arg1.into_raw(), extern$);
}

void rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_ServiceManager_cxxQtThreadClone(::CXX::ServiceManagerCxxQtThread const &cxx_qt_thread, ::CXX::ServiceManagerCxxQtThread *return$) noexcept {
  ::CXX::ServiceManagerCxxQtThread (*cxx_qt_ffi_ServiceManager_cxxQtThreadClone$)(::CXX::ServiceManagerCxxQtThread const &) = ::rust::cxxqt1::cxxQtThreadClone;
  new (return$) ::CXX::ServiceManagerCxxQtThread(cxx_qt_ffi_ServiceManager_cxxQtThreadClone$(cxx_qt_thread));
}

void rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_ServiceManager_cxxQtThreadDrop(::CXX::ServiceManagerCxxQtThread &cxx_qt_thread) noexcept {
  void (*cxx_qt_ffi_ServiceManager_cxxQtThreadDrop$)(::CXX::ServiceManagerCxxQtThread &) = ::rust::cxxqt1::cxxQtThreadDrop;
  cxx_qt_ffi_ServiceManager_cxxQtThreadDrop$(cxx_qt_thread);
}

bool rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_ServiceManager_cxxQtThreadIsDestroyed(::CXX::ServiceManagerCxxQtThread const &cxx_qt_thread) noexcept {
  bool (*cxx_qt_ffi_ServiceManager_cxxQtThreadIsDestroyed$)(::CXX::ServiceManagerCxxQtThread const &) = ::rust::cxxqt1::cxxQtThreadIsDestroyed;
  return cxx_qt_ffi_ServiceManager_cxxQtThreadIsDestroyed$(cxx_qt_thread);
}
} // extern "C"
} // namespace cxxqt1
} // namespace rust

namespace CXX {
namespace cxx_qt_ServiceManager {
extern "C" {
::std::size_t CXX$cxx_qt_ServiceManager$cxxbridge1$194$ServiceManagerCxxQtThreadQueuedFn$operator$sizeof() noexcept;
::std::size_t CXX$cxx_qt_ServiceManager$cxxbridge1$194$ServiceManagerCxxQtThreadQueuedFn$operator$alignof() noexcept;
} // extern "C"
} // namespace cxx_qt_ServiceManager
} // namespace CXX

namespace rust {
namespace cxxqt1 {
extern "C" {
::QObject const *rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_ServiceManager_upcastPtr(::CXX::ServiceManager const *thiz) noexcept {
  ::QObject const *(*cxx_qt_ffi_ServiceManager_upcastPtr$)(::CXX::ServiceManager const *) = ::rust::cxxqt1::upcastPtr;
  return cxx_qt_ffi_ServiceManager_upcastPtr$(thiz);
}

::CXX::ServiceManager const *rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_ServiceManager_downcastPtr(::QObject const *base) noexcept {
  ::CXX::ServiceManager const *(*cxx_qt_ffi_ServiceManager_downcastPtr$)(::QObject const *) = ::rust::cxxqt1::downcastPtr;
  return cxx_qt_ffi_ServiceManager_downcastPtr$(base);
}
} // extern "C"
} // namespace cxxqt1
} // namespace rust

namespace CXX {
namespace cxx_qt_ServiceManager {
extern "C" {
void CXX$cxx_qt_ServiceManager$cxxbridge1$194$route_arguments_ServiceManager_0(::QString *arg0, ::std::uint32_t arg1, ::CXX::cxx_qt_ServiceManager::CxxQtConstructorArguments0 *return$) noexcept;

::CXX::RServiceManager *CXX$cxx_qt_ServiceManager$cxxbridge1$194$new_rs_ServiceManager_0(::CXX::cxx_qt_ServiceManager::CxxQtConstructorNewArguments0 *args) noexcept;

void CXX$cxx_qt_ServiceManager$cxxbridge1$194$initialize_ServiceManager_0(::CXX::ServiceManager &qobject, ::CXX::cxx_qt_ServiceManager::CxxQtConstructorInitializeArguments0 *args) noexcept;
} // extern "C"
} // namespace cxx_qt_ServiceManager
} // namespace CXX

namespace rust {
namespace cxxqt1 {
extern "C" {
void rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_ServiceManager_unsafeRust(::CXX::ServiceManager const &outer, ::CXX::RServiceManager const **return$) noexcept {
  ::CXX::RServiceManager const &(*cxx_qt_ffi_ServiceManager_unsafeRust$)(::CXX::ServiceManager const &) = ::rust::cxxqt1::unsafeRust;
  new (return$) ::CXX::RServiceManager const *(&cxx_qt_ffi_ServiceManager_unsafeRust$(outer));
}

void rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_ServiceManager_unsafeRustMut(::CXX::ServiceManager &outer, ::CXX::RServiceManager **return$) noexcept {
  ::CXX::RServiceManager &(*cxx_qt_ffi_ServiceManager_unsafeRustMut$)(::CXX::ServiceManager &) = ::rust::cxxqt1::unsafeRustMut;
  new (return$) ::CXX::RServiceManager *(&cxx_qt_ffi_ServiceManager_unsafeRustMut$(outer));
}
} // extern "C"
} // namespace cxxqt1
} // namespace rust

namespace CXX {
::std::size_t RServiceManager::layout::size() noexcept {
  return CXX$cxxbridge1$194$RServiceManager$operator$sizeof();
}

::std::size_t RServiceManager::layout::align() noexcept {
  return CXX$cxxbridge1$194$RServiceManager$operator$alignof();
}

void ServiceManager::set_udid(::QString const &udid) noexcept {
  CXX$cxxbridge1$194$ServiceManager$set_udid(*this, udid);
}

void ServiceManager::get_cable_info() const noexcept {
  CXX$cxxbridge1$194$ServiceManager$get_cable_info(*this);
}

void ServiceManager::reveal_developer_mode_option_in_ui() const noexcept {
  CXX$cxxbridge1$194$ServiceManager$reveal_developer_mode_option_in_ui(*this);
}

void ServiceManager::query_mobilegestalt(::QList_QString const &keys) const noexcept {
  CXX$cxxbridge1$194$ServiceManager$query_mobilegestalt(*this, keys);
}

void ServiceManager::mount_dev_image(::QString const &image_path, ::QString const &sig) const noexcept {
  CXX$cxxbridge1$194$ServiceManager$mount_dev_image(*this, image_path, sig);
}

void ServiceManager::get_mounted_image() const noexcept {
  CXX$cxxbridge1$194$ServiceManager$get_mounted_image(*this);
}

void ServiceManager::fetch_installed_apps() const noexcept {
  CXX$cxxbridge1$194$ServiceManager$fetch_installed_apps(*this);
}

::std::int32_t ServiceManager::set_location(::QString const &latitude, ::QString const &longitude) const noexcept {
  return CXX$cxxbridge1$194$ServiceManager$set_location(*this, latitude, longitude);
}

void ServiceManager::fetch_app_icon(::QString bundle_id) const noexcept {
  ::rust::ManuallyDrop<::QString> bundle_id$(::std::move(bundle_id));
  CXX$cxxbridge1$194$ServiceManager$fetch_app_icon(*this, &bundle_id$.value);
}

void ServiceManager::fetch_disk_usage(bool skip_gallery_usage) const noexcept {
  CXX$cxxbridge1$194$ServiceManager$fetch_disk_usage(*this, skip_gallery_usage);
}

bool ServiceManager::restart() const noexcept {
  return CXX$cxxbridge1$194$ServiceManager$restart(*this);
}

bool ServiceManager::shutdown() const noexcept {
  return CXX$cxxbridge1$194$ServiceManager$shutdown(*this);
}

bool ServiceManager::enter_recovery_mode() const noexcept {
  return CXX$cxxbridge1$194$ServiceManager$enter_recovery_mode(*this);
}

void ServiceManager::install_ipa(::QString const &ipa_path) const noexcept {
  CXX$cxxbridge1$194$ServiceManager$install_ipa(*this, ipa_path);
}

void ServiceManager::enable_wifi_connections() const noexcept {
  CXX$cxxbridge1$194$ServiceManager$enable_wifi_connections(*this);
}

namespace rust {
namespace cxxqtgen1 {
void drop_ServiceManager_signal_handler_cable_info_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlercable_info_retrieved handler) noexcept {
  ::rust::ManuallyDrop<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlercable_info_retrieved> handler$(::std::move(handler));
  CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_cable_info_retrieved(&handler$.value);
}

void call_ServiceManager_signal_handler_cable_info_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlercable_info_retrieved &handler, ::CXX::ServiceManager &self_value, ::QString info) noexcept {
  ::rust::ManuallyDrop<::QString> info$(::std::move(info));
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_cable_info_retrieved(handler, self_value, &info$.value);
}

void drop_ServiceManager_signal_handler_mobilegestalt_info_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermobilegestalt_info_retrieved handler) noexcept {
  ::rust::ManuallyDrop<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermobilegestalt_info_retrieved> handler$(::std::move(handler));
  CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_mobilegestalt_info_retrieved(&handler$.value);
}

void call_ServiceManager_signal_handler_mobilegestalt_info_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermobilegestalt_info_retrieved &handler, ::CXX::ServiceManager &self_value, ::QMap_QString_QVariant info) noexcept {
  ::rust::ManuallyDrop<::QMap_QString_QVariant> info$(::std::move(info));
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_mobilegestalt_info_retrieved(handler, self_value, &info$.value);
}

void drop_ServiceManager_signal_handler_dev_image_mounted(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdev_image_mounted handler) noexcept {
  ::rust::ManuallyDrop<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdev_image_mounted> handler$(::std::move(handler));
  CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_dev_image_mounted(&handler$.value);
}

void call_ServiceManager_signal_handler_dev_image_mounted(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdev_image_mounted &handler, ::CXX::ServiceManager &self_value, bool success, bool is_locked) noexcept {
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_dev_image_mounted(handler, self_value, success, is_locked);
}

void drop_ServiceManager_signal_handler_developer_mode_option_revealed(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdeveloper_mode_option_revealed handler) noexcept {
  ::rust::ManuallyDrop<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdeveloper_mode_option_revealed> handler$(::std::move(handler));
  CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_developer_mode_option_revealed(&handler$.value);
}

void call_ServiceManager_signal_handler_developer_mode_option_revealed(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdeveloper_mode_option_revealed &handler, ::CXX::ServiceManager &self_value, bool success) noexcept {
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_developer_mode_option_revealed(handler, self_value, success);
}

void drop_ServiceManager_signal_handler_mounted_image_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermounted_image_retrieved handler) noexcept {
  ::rust::ManuallyDrop<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermounted_image_retrieved> handler$(::std::move(handler));
  CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_mounted_image_retrieved(&handler$.value);
}

void call_ServiceManager_signal_handler_mounted_image_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermounted_image_retrieved &handler, ::CXX::ServiceManager &self_value, bool success, bool is_locked, ::QByteArray sig, ::std::uint64_t sig_length) noexcept {
  ::rust::ManuallyDrop<::QByteArray> sig$(::std::move(sig));
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_mounted_image_retrieved(handler, self_value, success, is_locked, &sig$.value, sig_length);
}

void drop_ServiceManager_signal_handler_installed_apps_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstalled_apps_retrieved handler) noexcept {
  ::rust::ManuallyDrop<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstalled_apps_retrieved> handler$(::std::move(handler));
  CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_installed_apps_retrieved(&handler$.value);
}

void call_ServiceManager_signal_handler_installed_apps_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstalled_apps_retrieved &handler, ::CXX::ServiceManager &self_value, ::QMap_QString_QVariant const &apps) noexcept {
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_installed_apps_retrieved(handler, self_value, apps);
}

void drop_ServiceManager_signal_handler_app_icon_loaded(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerapp_icon_loaded handler) noexcept {
  ::rust::ManuallyDrop<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerapp_icon_loaded> handler$(::std::move(handler));
  CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_app_icon_loaded(&handler$.value);
}

void call_ServiceManager_signal_handler_app_icon_loaded(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerapp_icon_loaded &handler, ::CXX::ServiceManager &self_value, ::QString bundle_id, ::QByteArray icon_data) noexcept {
  ::rust::ManuallyDrop<::QString> bundle_id$(::std::move(bundle_id));
  ::rust::ManuallyDrop<::QByteArray> icon_data$(::std::move(icon_data));
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_app_icon_loaded(handler, self_value, &bundle_id$.value, &icon_data$.value);
}

void drop_ServiceManager_signal_handler_battery_info_updated(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerbattery_info_updated handler) noexcept {
  ::rust::ManuallyDrop<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerbattery_info_updated> handler$(::std::move(handler));
  CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_battery_info_updated(&handler$.value);
}

void call_ServiceManager_signal_handler_battery_info_updated(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerbattery_info_updated &handler, ::CXX::ServiceManager &self_value, ::QString const &info) noexcept {
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_battery_info_updated(handler, self_value, info);
}

void drop_ServiceManager_signal_handler_disk_usage_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdisk_usage_retrieved handler) noexcept {
  ::rust::ManuallyDrop<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdisk_usage_retrieved> handler$(::std::move(handler));
  CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_disk_usage_retrieved(&handler$.value);
}

void call_ServiceManager_signal_handler_disk_usage_retrieved(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdisk_usage_retrieved &handler, ::CXX::ServiceManager &self_value, bool success, ::std::uint64_t apps_usage, ::std::uint64_t gallery_usage) noexcept {
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_disk_usage_retrieved(handler, self_value, success, apps_usage, gallery_usage);
}

void drop_ServiceManager_signal_handler_install_ipa_init(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_init handler) noexcept {
  ::rust::ManuallyDrop<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_init> handler$(::std::move(handler));
  CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_install_ipa_init(&handler$.value);
}

void call_ServiceManager_signal_handler_install_ipa_init(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_init &handler, ::CXX::ServiceManager &self_value, bool started, ::QString state) noexcept {
  ::rust::ManuallyDrop<::QString> state$(::std::move(state));
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_install_ipa_init(handler, self_value, started, &state$.value);
}

void drop_ServiceManager_signal_handler_install_ipa_progress(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_progress handler) noexcept {
  ::rust::ManuallyDrop<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_progress> handler$(::std::move(handler));
  CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_install_ipa_progress(&handler$.value);
}

void call_ServiceManager_signal_handler_install_ipa_progress(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_progress &handler, ::CXX::ServiceManager &self_value, double progress, ::QString state) noexcept {
  ::rust::ManuallyDrop<::QString> state$(::std::move(state));
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_install_ipa_progress(handler, self_value, progress, &state$.value);
}

void drop_ServiceManager_signal_handler_enable_wifi_connections_result(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerenable_wifi_connections_result handler) noexcept {
  ::rust::ManuallyDrop<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerenable_wifi_connections_result> handler$(::std::move(handler));
  CXX$rust$cxxqtgen1$cxxbridge1$194$drop_ServiceManager_signal_handler_enable_wifi_connections_result(&handler$.value);
}

void call_ServiceManager_signal_handler_enable_wifi_connections_result(::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerenable_wifi_connections_result &handler, ::CXX::ServiceManager &self_value, bool success) noexcept {
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_ServiceManager_signal_handler_enable_wifi_connections_result(handler, self_value, success);
}
} // namespace cxxqtgen1
} // namespace rust

namespace cxx_qt_ServiceManager {
::std::size_t ServiceManagerCxxQtThreadQueuedFn::layout::size() noexcept {
  return CXX$cxx_qt_ServiceManager$cxxbridge1$194$ServiceManagerCxxQtThreadQueuedFn$operator$sizeof();
}

::std::size_t ServiceManagerCxxQtThreadQueuedFn::layout::align() noexcept {
  return CXX$cxx_qt_ServiceManager$cxxbridge1$194$ServiceManagerCxxQtThreadQueuedFn$operator$alignof();
}

::CXX::cxx_qt_ServiceManager::CxxQtConstructorArguments0 routeArguments0(::QString arg0, ::std::uint32_t arg1) noexcept {
  ::rust::ManuallyDrop<::QString> arg0$(::std::move(arg0));
  ::rust::MaybeUninit<::CXX::cxx_qt_ServiceManager::CxxQtConstructorArguments0> return$;
  CXX$cxx_qt_ServiceManager$cxxbridge1$194$route_arguments_ServiceManager_0(&arg0$.value, arg1, &return$.value);
  return ::std::move(return$.value);
}

::rust::Box<::CXX::RServiceManager> newRs0(::CXX::cxx_qt_ServiceManager::CxxQtConstructorNewArguments0 args) noexcept {
  ::rust::ManuallyDrop<::CXX::cxx_qt_ServiceManager::CxxQtConstructorNewArguments0> args$(::std::move(args));
  return ::rust::Box<::CXX::RServiceManager>::from_raw(CXX$cxx_qt_ServiceManager$cxxbridge1$194$new_rs_ServiceManager_0(&args$.value));
}

void initialize0(::CXX::ServiceManager &qobject, ::CXX::cxx_qt_ServiceManager::CxxQtConstructorInitializeArguments0 args) noexcept {
  ::rust::ManuallyDrop<::CXX::cxx_qt_ServiceManager::CxxQtConstructorInitializeArguments0> args$(::std::move(args));
  CXX$cxx_qt_ServiceManager$cxxbridge1$194$initialize_ServiceManager_0(qobject, &args$.value);
}
} // namespace cxx_qt_ServiceManager
} // namespace CXX

extern "C" {
::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn *cxxbridge1$box$CXX$cxx_qt_ServiceManager$ServiceManagerCxxQtThreadQueuedFn$alloc() noexcept;
void cxxbridge1$box$CXX$cxx_qt_ServiceManager$ServiceManagerCxxQtThreadQueuedFn$dealloc(::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn *) noexcept;
void cxxbridge1$box$CXX$cxx_qt_ServiceManager$ServiceManagerCxxQtThreadQueuedFn$drop(::rust::Box<::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn> *ptr) noexcept;

::CXX::RServiceManager *cxxbridge1$box$CXX$RServiceManager$alloc() noexcept;
void cxxbridge1$box$CXX$RServiceManager$dealloc(::CXX::RServiceManager *) noexcept;
void cxxbridge1$box$CXX$RServiceManager$drop(::rust::Box<::CXX::RServiceManager> *ptr) noexcept;
} // extern "C"

namespace rust {
inline namespace cxxbridge1 {
template <>
::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn *Box<::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn>::allocation::alloc() noexcept {
  return cxxbridge1$box$CXX$cxx_qt_ServiceManager$ServiceManagerCxxQtThreadQueuedFn$alloc();
}
template <>
void Box<::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn>::allocation::dealloc(::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn *ptr) noexcept {
  cxxbridge1$box$CXX$cxx_qt_ServiceManager$ServiceManagerCxxQtThreadQueuedFn$dealloc(ptr);
}
template <>
void Box<::CXX::cxx_qt_ServiceManager::ServiceManagerCxxQtThreadQueuedFn>::drop() noexcept {
  cxxbridge1$box$CXX$cxx_qt_ServiceManager$ServiceManagerCxxQtThreadQueuedFn$drop(this);
}
template <>
::CXX::RServiceManager *Box<::CXX::RServiceManager>::allocation::alloc() noexcept {
  return cxxbridge1$box$CXX$RServiceManager$alloc();
}
template <>
void Box<::CXX::RServiceManager>::allocation::dealloc(::CXX::RServiceManager *ptr) noexcept {
  cxxbridge1$box$CXX$RServiceManager$dealloc(ptr);
}
template <>
void Box<::CXX::RServiceManager>::drop() noexcept {
  cxxbridge1$box$CXX$RServiceManager$drop(this);
}
} // namespace cxxbridge1
} // namespace rust
