#include "cxx-qt-lib/qstring.h"
#include "cxx-qt-lib/qlist.h"
#include "cxx-qt-lib/quuid.h"
#include <QtCore/QObject>
#include "cxx-qt/connection.h"
#include "idescriptor_rust_codebase/src/io_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

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

namespace CXX {
  using IOManager = ::CXX::IOManager;
  struct RIOManager;
  namespace cxx_qt_IOManager {
    struct IOManagerCxxQtThreadQueuedFn;
  }
}

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

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

namespace cxx_qt_IOManager {
#ifndef CXXBRIDGE1_STRUCT_CXX$cxx_qt_IOManager$IOManagerCxxQtThreadQueuedFn
#define CXXBRIDGE1_STRUCT_CXX$cxx_qt_IOManager$IOManagerCxxQtThreadQueuedFn
struct IOManagerCxxQtThreadQueuedFn final : public ::rust::Opaque {
  ~IOManagerCxxQtThreadQueuedFn() = 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_IOManager$IOManagerCxxQtThreadQueuedFn
} // namespace cxx_qt_IOManager
} // namespace CXX

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 `IOManager_connect_file_transfer_progress`, `IOManager_connect_export_item_finished`, `IOManager_connect_export_job_finished` 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 `IOManager_connect_file_transfer_progress`, `IOManager_connect_export_item_finished`, `IOManager_connect_export_job_finished` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerfile_transfer_progress>::value,
    "type CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerfile_transfer_progress should be trivially move constructible and trivially destructible in C++ to be used as an argument of `IOManager_connect_file_transfer_progress`, `drop_IOManager_signal_handler_file_transfer_progress` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerexport_item_finished>::value,
    "type CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerexport_item_finished should be trivially move constructible and trivially destructible in C++ to be used as an argument of `IOManager_connect_export_item_finished`, `drop_IOManager_signal_handler_export_item_finished` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerexport_job_finished>::value,
    "type CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerexport_job_finished should be trivially move constructible and trivially destructible in C++ to be used as an argument of `IOManager_connect_export_job_finished`, `drop_IOManager_signal_handler_export_job_finished` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerimport_item_finished>::value,
    "type CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerimport_item_finished should be trivially move constructible and trivially destructible in C++ to be used as an argument of `IOManager_connect_import_item_finished`, `drop_IOManager_signal_handler_import_item_finished` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerimport_job_finished>::value,
    "type CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerimport_job_finished should be trivially move constructible and trivially destructible in C++ to be used as an argument of `IOManager_connect_import_job_finished`, `drop_IOManager_signal_handler_import_job_finished` in Rust");
static_assert(
    ::rust::IsRelocatable<::CXX::IOManagerCxxQtThread>::value,
    "type CXX::IOManagerCxxQtThread should be trivially move constructible and trivially destructible in C++ to be used as a return value of `cxx_qt_ffi_IOManager_qtThread`, `cxx_qt_ffi_IOManager_cxxQtThreadClone` in Rust");

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

void CXX$cxxbridge1$194$IOManager$start_export(::CXX::IOManager &self, ::QString const &udid, ::QUuid const &job_id, ::QList_QString const &device_paths, ::QString const &destination_dir) noexcept;

void CXX$cxxbridge1$194$IOManager$start_export_with_afc2(::CXX::IOManager &self, ::QString const &udid, ::QUuid const &job_id, ::QList_QString const &device_paths, ::QString const &destination_dir) noexcept;

void CXX$cxxbridge1$194$IOManager$start_export_with_hause_arrest_afc(::CXX::IOManager &self, ::QString const &udid, ::QUuid const &job_id, ::QList_QString const &device_paths, ::QString const &destination_dir, ::QString const &hause_arrest_afc) noexcept;

void CXX$cxxbridge1$194$IOManager$start_import(::CXX::IOManager &self, ::QString const &udid, ::QUuid const &job_id, ::QList_QString const &local_paths, ::QString const &destination_dir) noexcept;

void CXX$cxxbridge1$194$IOManager$start_import_with_afc2(::CXX::IOManager &self, ::QString const &udid, ::QUuid const &job_id, ::QList_QString const &local_paths, ::QString const &destination_dir) noexcept;

void CXX$cxxbridge1$194$IOManager$start_import_with_hause_arrest_afc(::CXX::IOManager &self, ::QString const &udid, ::QUuid const &job_id, ::QList_QString const &local_paths, ::QString const &destination_dir, ::QString const &hause_arrest_afc) noexcept;

void CXX$cxxbridge1$194$IOManager$cancel_job(::CXX::IOManager &self, ::QUuid const &job_id) noexcept;

void CXX$cxxbridge1$194$IOManager$cancel_all_jobs(::CXX::IOManager &self) noexcept;

void CXX$cxxbridge1$194$IOManager$release_video_streamer(::CXX::IOManager const &self, ::QString const &udid, ::QString const &url) noexcept;

void CXX$cxxbridge1$194$IOManager$file_transfer_progress(::CXX::IOManager &self, ::QUuid const &job_id, ::QString const &file_name, ::std::int64_t bytes_transferred, ::std::int64_t total_bytes) noexcept {
  void (::CXX::IOManager::*file_transfer_progress$)(::QUuid const &, ::QString const &, ::std::int64_t, ::std::int64_t) = &::CXX::IOManager::file_transfer_progress;
  (self.*file_transfer_progress$)(job_id, file_name, bytes_transferred, total_bytes);
}
} // extern "C"

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

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_IOManager_signal_handler_file_transfer_progress(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerfile_transfer_progress *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_IOManager_signal_handler_file_transfer_progress(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerfile_transfer_progress &handler, ::CXX::IOManager &self_value, ::QUuid const &job_id, ::QString const &file_name, ::std::int64_t bytes_transferred, ::std::int64_t total_bytes) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$IOManager$export_item_finished(::CXX::IOManager &self, ::QUuid const &job_id, ::QString const &file_name, ::QString const &destination_path, bool success, ::std::int64_t bytes_transferred, ::QString const &error_message) noexcept {
  void (::CXX::IOManager::*export_item_finished$)(::QUuid const &, ::QString const &, ::QString const &, bool, ::std::int64_t, ::QString const &) = &::CXX::IOManager::export_item_finished;
  (self.*export_item_finished$)(job_id, file_name, destination_path, success, bytes_transferred, error_message);
}
} // extern "C"

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

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_IOManager_signal_handler_export_item_finished(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerexport_item_finished *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_IOManager_signal_handler_export_item_finished(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerexport_item_finished &handler, ::CXX::IOManager &self_value, ::QUuid const &job_id, ::QString const &file_name, ::QString const &destination_path, bool success, ::std::int64_t bytes_transferred, ::QString const &error_message) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$IOManager$export_job_finished(::CXX::IOManager &self, ::QUuid const &job_id, bool cancelled, ::std::int32_t successful_items, ::std::int32_t failed_items, ::std::int64_t total_bytes) noexcept {
  void (::CXX::IOManager::*export_job_finished$)(::QUuid const &, bool, ::std::int32_t, ::std::int32_t, ::std::int64_t) = &::CXX::IOManager::export_job_finished;
  (self.*export_job_finished$)(job_id, cancelled, successful_items, failed_items, total_bytes);
}
} // extern "C"

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

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_IOManager_signal_handler_export_job_finished(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerexport_job_finished *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_IOManager_signal_handler_export_job_finished(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerexport_job_finished &handler, ::CXX::IOManager &self_value, ::QUuid const &job_id, bool cancelled, ::std::int32_t successful_items, ::std::int32_t failed_items, ::std::int64_t total_bytes) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$IOManager$import_item_finished(::CXX::IOManager &self, ::QUuid const &job_id, ::QString const &file_name, ::QString const &destination_path, bool success, ::std::int64_t bytes_transferred, ::QString const &error_message) noexcept {
  void (::CXX::IOManager::*import_item_finished$)(::QUuid const &, ::QString const &, ::QString const &, bool, ::std::int64_t, ::QString const &) = &::CXX::IOManager::import_item_finished;
  (self.*import_item_finished$)(job_id, file_name, destination_path, success, bytes_transferred, error_message);
}
} // extern "C"

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

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_IOManager_signal_handler_import_item_finished(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerimport_item_finished *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_IOManager_signal_handler_import_item_finished(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerimport_item_finished &handler, ::CXX::IOManager &self_value, ::QUuid const &job_id, ::QString const &file_name, ::QString const &destination_path, bool success, ::std::int64_t bytes_transferred, ::QString const &error_message) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust

extern "C" {
void CXX$cxxbridge1$194$IOManager$import_job_finished(::CXX::IOManager &self, ::QUuid const &job_id, bool cancelled, ::std::int32_t successful_items, ::std::int32_t failed_items, ::std::int64_t total_bytes) noexcept {
  void (::CXX::IOManager::*import_job_finished$)(::QUuid const &, bool, ::std::int32_t, ::std::int32_t, ::std::int64_t) = &::CXX::IOManager::import_job_finished;
  (self.*import_job_finished$)(job_id, cancelled, successful_items, failed_items, total_bytes);
}
} // extern "C"

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

void CXX$rust$cxxqtgen1$cxxbridge1$194$drop_IOManager_signal_handler_import_job_finished(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerimport_job_finished *handler) noexcept;

void CXX$rust$cxxqtgen1$cxxbridge1$194$call_IOManager_signal_handler_import_job_finished(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerimport_job_finished &handler, ::CXX::IOManager &self_value, ::QUuid const &job_id, bool cancelled, ::std::int32_t successful_items, ::std::int32_t failed_items, ::std::int64_t total_bytes) noexcept;
} // extern "C"
} // namespace cxxqtgen1
} // namespace rust
} // namespace CXX

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

::std::uint8_t rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_IOManager_cxxQtThreadQueue(::CXX::IOManagerCxxQtThread const &cxx_qt_thread, ::rust::Fn<void(::CXX::IOManager &, ::rust::Box<::CXX::cxx_qt_IOManager::IOManagerCxxQtThreadQueuedFn>)> func, ::CXX::cxx_qt_IOManager::IOManagerCxxQtThreadQueuedFn *arg) noexcept {
  ::std::uint8_t (*cxx_qt_ffi_IOManager_cxxQtThreadQueue$)(::CXX::IOManagerCxxQtThread const &, ::rust::Fn<void(::CXX::IOManager &, ::rust::Box<::CXX::cxx_qt_IOManager::IOManagerCxxQtThreadQueuedFn>)>, ::rust::Box<::CXX::cxx_qt_IOManager::IOManagerCxxQtThreadQueuedFn>) = ::rust::cxxqt1::cxxQtThreadQueue;
  return cxx_qt_ffi_IOManager_cxxQtThreadQueue$(cxx_qt_thread, func, ::rust::Box<::CXX::cxx_qt_IOManager::IOManagerCxxQtThreadQueuedFn>::from_raw(arg));
}

void rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_IOManager_cxxQtThreadQueue$func$1(::CXX::IOManager &arg0, ::CXX::cxx_qt_IOManager::IOManagerCxxQtThreadQueuedFn *arg1, void *) noexcept;

void rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_IOManager_cxxQtThreadQueue$func$0(::CXX::IOManager &arg0, ::rust::Box<::CXX::cxx_qt_IOManager::IOManagerCxxQtThreadQueuedFn> arg1, void *extern$) noexcept {
  rust$cxxqt1$cxxbridge1$194$cxx_qt_ffi_IOManager_cxxQtThreadQueue$func$1(arg0, arg1.into_raw(), extern$);
}

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

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

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

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

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

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

namespace CXX {
namespace cxx_qt_IOManager {
extern "C" {
::CXX::RIOManager *CXX$cxx_qt_IOManager$cxxbridge1$194$create_rs_RIOManager() noexcept;
} // extern "C"
} // namespace cxx_qt_IOManager
} // namespace CXX

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

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

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

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

void IOManager::start_export(::QString const &udid, ::QUuid const &job_id, ::QList_QString const &device_paths, ::QString const &destination_dir) noexcept {
  CXX$cxxbridge1$194$IOManager$start_export(*this, udid, job_id, device_paths, destination_dir);
}

void IOManager::start_export_with_afc2(::QString const &udid, ::QUuid const &job_id, ::QList_QString const &device_paths, ::QString const &destination_dir) noexcept {
  CXX$cxxbridge1$194$IOManager$start_export_with_afc2(*this, udid, job_id, device_paths, destination_dir);
}

void IOManager::start_export_with_hause_arrest_afc(::QString const &udid, ::QUuid const &job_id, ::QList_QString const &device_paths, ::QString const &destination_dir, ::QString const &hause_arrest_afc) noexcept {
  CXX$cxxbridge1$194$IOManager$start_export_with_hause_arrest_afc(*this, udid, job_id, device_paths, destination_dir, hause_arrest_afc);
}

void IOManager::start_import(::QString const &udid, ::QUuid const &job_id, ::QList_QString const &local_paths, ::QString const &destination_dir) noexcept {
  CXX$cxxbridge1$194$IOManager$start_import(*this, udid, job_id, local_paths, destination_dir);
}

void IOManager::start_import_with_afc2(::QString const &udid, ::QUuid const &job_id, ::QList_QString const &local_paths, ::QString const &destination_dir) noexcept {
  CXX$cxxbridge1$194$IOManager$start_import_with_afc2(*this, udid, job_id, local_paths, destination_dir);
}

void IOManager::start_import_with_hause_arrest_afc(::QString const &udid, ::QUuid const &job_id, ::QList_QString const &local_paths, ::QString const &destination_dir, ::QString const &hause_arrest_afc) noexcept {
  CXX$cxxbridge1$194$IOManager$start_import_with_hause_arrest_afc(*this, udid, job_id, local_paths, destination_dir, hause_arrest_afc);
}

void IOManager::cancel_job(::QUuid const &job_id) noexcept {
  CXX$cxxbridge1$194$IOManager$cancel_job(*this, job_id);
}

void IOManager::cancel_all_jobs() noexcept {
  CXX$cxxbridge1$194$IOManager$cancel_all_jobs(*this);
}

void IOManager::release_video_streamer(::QString const &udid, ::QString const &url) const noexcept {
  CXX$cxxbridge1$194$IOManager$release_video_streamer(*this, udid, url);
}

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

void call_IOManager_signal_handler_file_transfer_progress(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerfile_transfer_progress &handler, ::CXX::IOManager &self_value, ::QUuid const &job_id, ::QString const &file_name, ::std::int64_t bytes_transferred, ::std::int64_t total_bytes) noexcept {
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_IOManager_signal_handler_file_transfer_progress(handler, self_value, job_id, file_name, bytes_transferred, total_bytes);
}

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

void call_IOManager_signal_handler_export_item_finished(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerexport_item_finished &handler, ::CXX::IOManager &self_value, ::QUuid const &job_id, ::QString const &file_name, ::QString const &destination_path, bool success, ::std::int64_t bytes_transferred, ::QString const &error_message) noexcept {
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_IOManager_signal_handler_export_item_finished(handler, self_value, job_id, file_name, destination_path, success, bytes_transferred, error_message);
}

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

void call_IOManager_signal_handler_export_job_finished(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerexport_job_finished &handler, ::CXX::IOManager &self_value, ::QUuid const &job_id, bool cancelled, ::std::int32_t successful_items, ::std::int32_t failed_items, ::std::int64_t total_bytes) noexcept {
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_IOManager_signal_handler_export_job_finished(handler, self_value, job_id, cancelled, successful_items, failed_items, total_bytes);
}

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

void call_IOManager_signal_handler_import_item_finished(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerimport_item_finished &handler, ::CXX::IOManager &self_value, ::QUuid const &job_id, ::QString const &file_name, ::QString const &destination_path, bool success, ::std::int64_t bytes_transferred, ::QString const &error_message) noexcept {
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_IOManager_signal_handler_import_item_finished(handler, self_value, job_id, file_name, destination_path, success, bytes_transferred, error_message);
}

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

void call_IOManager_signal_handler_import_job_finished(::CXX::rust::cxxqtgen1::IOManagerCxxQtSignalHandlerimport_job_finished &handler, ::CXX::IOManager &self_value, ::QUuid const &job_id, bool cancelled, ::std::int32_t successful_items, ::std::int32_t failed_items, ::std::int64_t total_bytes) noexcept {
  CXX$rust$cxxqtgen1$cxxbridge1$194$call_IOManager_signal_handler_import_job_finished(handler, self_value, job_id, cancelled, successful_items, failed_items, total_bytes);
}
} // namespace cxxqtgen1
} // namespace rust

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

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

::rust::Box<::CXX::RIOManager> createRs() noexcept {
  return ::rust::Box<::CXX::RIOManager>::from_raw(CXX$cxx_qt_IOManager$cxxbridge1$194$create_rs_RIOManager());
}
} // namespace cxx_qt_IOManager
} // namespace CXX

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

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

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