ruby-qt6-qtdbus 1.0.0

data/ext/qt6/qtdbus/qdbusinterface-rb.cpp

@@ -0,0 +1,17 @@
+#include "qdbusinterface-rb.hpp"
+#include <qdbusinterface.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQDBusInterface;
+
+void Init_qdbusinterface(Rice::Module rb_mQt6QtDBus)
+{
+    rb_cQDBusInterface =
+        // RubyQt6::QtDBus::QDBusInterface
+        define_class_under<QDBusInterface, QDBusAbstractInterface>(rb_mQt6QtDBus, "QDBusInterface")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QDBusInterface::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QDBusInterface, const QString &, const QString &, const QString &, const QDBusConnection &, QObject *>(), Arg("service"), Arg("path"), Arg("interface"), Arg("connection"), Arg("parent"));
+}

data/ext/qt6/qtdbus/qdbusinterface-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qdbusinterface(Rice::Module rb_mQt6QtDBus);

data/ext/qt6/qtdbus/qdbusmessage-rb.cpp

@@ -0,0 +1,55 @@
+#include "qdbusmessage-rb.hpp"
+#include <qdbusmessage.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQDBusMessage;
+
+void Init_qdbusmessage(Rice::Module rb_mQt6QtDBus)
+{
+    rb_cQDBusMessage =
+        // RubyQt6::QtDBus::QDBusMessage
+        define_class_under<QDBusMessage>(rb_mQt6QtDBus, "QDBusMessage")
+            // Constructor
+            .define_constructor(Constructor<QDBusMessage>())
+            // Public Functions
+            .define_method("arguments", &QDBusMessage::arguments)
+            .define_method("auto_start_service", &QDBusMessage::autoStartService)
+            .define_method<QDBusMessage (QDBusMessage::*)(QDBusError::ErrorType, const QString &) const>("create_error_reply", &QDBusMessage::createErrorReply, Arg("type"), Arg("msg"))
+            .define_method<QDBusMessage (QDBusMessage::*)(const QDBusError &) const>("create_error_reply", &QDBusMessage::createErrorReply, Arg("err"))
+            .define_method<QDBusMessage (QDBusMessage::*)(const QString &, const QString &) const>("create_error_reply", &QDBusMessage::createErrorReply, Arg("name"), Arg("msg"))
+            .define_method<QDBusMessage (QDBusMessage::*)(const QList<QVariant> &) const>("create_reply", &QDBusMessage::createReply, Arg("arguments") = static_cast<const QList<QVariant> &>(QList<QVariant>()))
+            .define_method<QDBusMessage (QDBusMessage::*)(const QVariant &) const>("create_reply", &QDBusMessage::createReply, Arg("argument"))
+            .define_method("error_message", &QDBusMessage::errorMessage)
+            .define_method("error_name", &QDBusMessage::errorName)
+            .define_method("interface", &QDBusMessage::interface)
+            .define_method("delayed_reply?", &QDBusMessage::isDelayedReply)
+            .define_method("interactive_authorization_allowed?", &QDBusMessage::isInteractiveAuthorizationAllowed)
+            .define_method("reply_required?", &QDBusMessage::isReplyRequired)
+            .define_method("member", &QDBusMessage::member)
+            .define_method("path", &QDBusMessage::path)
+            .define_method("service", &QDBusMessage::service)
+            .define_method("_set_arguments", &QDBusMessage::setArguments, Arg("arguments"))
+            .define_method("set_auto_start_service", &QDBusMessage::setAutoStartService, Arg("enable"))
+            .define_method("set_delayed_reply", &QDBusMessage::setDelayedReply, Arg("enable"))
+            .define_method("set_interactive_authorization_allowed", &QDBusMessage::setInteractiveAuthorizationAllowed, Arg("enable"))
+            .define_method("signature", &QDBusMessage::signature)
+            .define_method("type", &QDBusMessage::type)
+            // Static Public Members
+            .define_singleton_function<QDBusMessage (*)(QDBusError::ErrorType, const QString &)>("create_error", &QDBusMessage::createError, Arg("type"), Arg("msg"))
+            .define_singleton_function<QDBusMessage (*)(const QDBusError &)>("create_error", &QDBusMessage::createError, Arg("err"))
+            .define_singleton_function<QDBusMessage (*)(const QString &, const QString &)>("create_error", &QDBusMessage::createError, Arg("name"), Arg("msg"))
+            .define_singleton_function("_create_method_call", &QDBusMessage::createMethodCall, Arg("destination"), Arg("path"), Arg("interface"), Arg("method"))
+            .define_singleton_function("_create_signal", &QDBusMessage::createSignal, Arg("path"), Arg("interface"), Arg("name"))
+            .define_singleton_function("_create_targeted_signal", &QDBusMessage::createTargetedSignal, Arg("service"), Arg("path"), Arg("interface"), Arg("name"));
+
+    Data_Type<QDBusMessage::MessageType> rb_cQDBusMessageMessageType =
+        // RubyQt6::QtDBus::QDBusMessage::MessageType
+        define_qenum_under<QDBusMessage::MessageType>(rb_cQDBusMessage, "MessageType");
+        define_qenum_value_under(rb_cQDBusMessageMessageType, "InvalidMessage", QDBusMessage::MessageType::InvalidMessage);
+        define_qenum_value_under(rb_cQDBusMessageMessageType, "MethodCallMessage", QDBusMessage::MessageType::MethodCallMessage);
+        define_qenum_value_under(rb_cQDBusMessageMessageType, "ReplyMessage", QDBusMessage::MessageType::ReplyMessage);
+        define_qenum_value_under(rb_cQDBusMessageMessageType, "ErrorMessage", QDBusMessage::MessageType::ErrorMessage);
+        define_qenum_value_under(rb_cQDBusMessageMessageType, "SignalMessage", QDBusMessage::MessageType::SignalMessage);
+}

data/ext/qt6/qtdbus/qdbusmessage-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qdbusmessage(Rice::Module rb_mQt6QtDBus);

data/ext/qt6/qtdbus/qdbusservicewatcher-rb.cpp

@@ -0,0 +1,48 @@
+#include "qdbusservicewatcher-rb.hpp"
+#include <qdbusservicewatcher.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+#include <QBindable>
+#include <QDBusConnection>
+
+using namespace Rice;
+
+Rice::Class rb_cQDBusServiceWatcher;
+
+void Init_qdbusservicewatcher(Rice::Module rb_mQt6QtDBus)
+{
+    rb_cQDBusServiceWatcher =
+        // RubyQt6::QtDBus::QDBusServiceWatcher
+        define_class_under<QDBusServiceWatcher, QObject>(rb_mQt6QtDBus, "QDBusServiceWatcher")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QDBusServiceWatcher::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QDBusServiceWatcher, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("_add_watched_service", &QDBusServiceWatcher::addWatchedService, Arg("new_service"))
+            .define_method("bindable_watch_mode", &QDBusServiceWatcher::bindableWatchMode)
+            .define_method("bindable_watched_services", &QDBusServiceWatcher::bindableWatchedServices)
+            .define_method("connection", &QDBusServiceWatcher::connection)
+            .define_method("remove_watched_service", &QDBusServiceWatcher::removeWatchedService, Arg("service"))
+            .define_method("set_connection", &QDBusServiceWatcher::setConnection, Arg("connection"))
+            .define_method("set_watch_mode", &QDBusServiceWatcher::setWatchMode, Arg("mode"))
+            .define_method("set_watched_services", &QDBusServiceWatcher::setWatchedServices, Arg("services"))
+            .define_method("watch_mode", &QDBusServiceWatcher::watchMode)
+            .define_method("watched_services", &QDBusServiceWatcher::watchedServices)
+            // Signals
+            .define_method("service_owner_changed", &QDBusServiceWatcher::serviceOwnerChanged, Arg("service"), Arg("old_owner"), Arg("new_owner"))
+            .define_method("service_registered", &QDBusServiceWatcher::serviceRegistered, Arg("service"))
+            .define_method("service_unregistered", &QDBusServiceWatcher::serviceUnregistered, Arg("service"));
+
+    Data_Type<QDBusServiceWatcher::WatchModeFlag> rb_cQDBusServiceWatcherWatchModeFlag =
+        // RubyQt6::QtDBus::QDBusServiceWatcher::WatchModeFlag
+        define_qenum_under<QDBusServiceWatcher::WatchModeFlag>(rb_cQDBusServiceWatcher, "WatchModeFlag");
+        define_qenum_value_under(rb_cQDBusServiceWatcherWatchModeFlag, "WatchForRegistration", QDBusServiceWatcher::WatchModeFlag::WatchForRegistration);
+        define_qenum_value_under(rb_cQDBusServiceWatcherWatchModeFlag, "WatchForUnregistration", QDBusServiceWatcher::WatchModeFlag::WatchForUnregistration);
+        define_qenum_value_under(rb_cQDBusServiceWatcherWatchModeFlag, "WatchForOwnerChange", QDBusServiceWatcher::WatchModeFlag::WatchForOwnerChange);
+
+    Data_Type<QFlags<QDBusServiceWatcher::WatchModeFlag>> rb_cQDBusServiceWatcherWatchMode =
+        // RubyQt6::QtDBus::QDBusServiceWatcher::WatchMode
+        define_qflags_under<QDBusServiceWatcher::WatchModeFlag>(rb_cQDBusServiceWatcher, "WatchMode");
+}

data/ext/qt6/qtdbus/qdbusservicewatcher-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qdbusservicewatcher(Rice::Module rb_mQt6QtDBus);

data/ext/qt6/qtdbus/qdbusvariant-rb.cpp

@@ -0,0 +1,23 @@
+#include "qdbusvariant-rb.hpp"
+#include <qdbusextratypes.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQDBusVariant;
+
+void Init_qdbusvariant(Rice::Module rb_mQt6QtDBus)
+{
+
+    rb_cQDBusVariant =
+        // RubyQt6::QtDBus::QDBusVariant
+        define_class_under<QDBusVariant>(rb_mQt6QtDBus, "QDBusVariant")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_qvariant_register_metatype", []() -> int { return qRegisterMetaType<QDBusVariant>(); })
+            .define_singleton_function("_qvariant_from_value", [](const QDBusVariant &value) -> QVariant { return QVariant::fromValue(value); })
+            .define_singleton_function("_qvariant_to_value", [](const QVariant &qvariant) -> QDBusVariant { return qvariant.value<QDBusVariant>(); })
+            // Constructor
+            .define_constructor(Constructor<QDBusVariant, const QVariant &>(), Arg("variant"))
+            // Public Functions
+            .define_method("set_variant", &QDBusVariant::setVariant, Arg("variant"))
+            .define_method("variant", &QDBusVariant::variant);
+}

data/ext/qt6/qtdbus/qdbusvariant-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qdbusvariant(Rice::Module rb_mQt6QtDBus);

data/ext/qt6/qtdbus/qtdbus-rb.cpp

@@ -0,0 +1,48 @@
+#include "qtdbus-rb.hpp"
+#include "qtdbusversion-rb.hpp"
+#include "qdbus-enum-rb.hpp"
+
+#include "qdbusconnection-rb.hpp"
+#include "qdbuserror-rb.hpp"
+#include "qdbusmessage-rb.hpp"
+#include "qdbusvariant-rb.hpp"
+
+#include "qdbusabstractadaptor-rb.hpp"
+#include "qdbusabstractinterface-rb.hpp"
+#include "qdbusconnectioninterface-rb.hpp"
+#include "qdbusinterface-rb.hpp"
+#include "qdbusservicewatcher-rb.hpp"
+
+#include "t-qtdbus-rb.hpp"
+
+#include "bando-qdbusabstractadaptor-rb.hpp"
+#include "bando-qdbusabstractinterface-rb.hpp"
+
+extern "C" void Init_qtdbus()
+{
+    return Rice::detail::cpp_protect([] {
+        Rice::Module rb_mQt6 = Rice::define_module("RubyQt6");
+        Rice::Module rb_mQt6QtDBus = define_module_under(rb_mQt6, "QtDBus");
+
+        Init_qtdbusversion(rb_mQt6QtDBus);
+        Init_qdbus_enum(rb_mQt6QtDBus);
+
+        Init_qdbusconnection(rb_mQt6QtDBus);
+        Init_qdbuserror(rb_mQt6QtDBus);
+        Init_qdbusmessage(rb_mQt6QtDBus);
+        Init_qdbusvariant(rb_mQt6QtDBus);
+
+        Init_qdbusabstractadaptor(rb_mQt6QtDBus);
+        Init_qdbusabstractinterface(rb_mQt6QtDBus);
+        Init_qdbusconnectioninterface(rb_mQt6QtDBus);
+        Init_qdbusinterface(rb_mQt6QtDBus);
+        Init_qdbusservicewatcher(rb_mQt6QtDBus);
+
+        Rice::Module rb_mQt6T = define_module_under(rb_mQt6, "T");
+        Init_t_qtdbus(rb_mQt6T);
+
+        Rice::Module rb_mQt6Bando = define_module_under(rb_mQt6, "Bando");
+        Init_bando_qdbusabstractadaptor(rb_mQt6Bando);
+        Init_bando_qdbusabstractinterface(rb_mQt6Bando);
+    });
+}

data/ext/qt6/qtdbus/qtdbus-rb.hpp

@@ -0,0 +1,3 @@
+#include <rice/rice.hpp>
+
+extern "C" void Init_qtdbus();

data/ext/qt6/qtdbus/qtdbusversion-rb.cpp

@@ -0,0 +1,9 @@
+#include "qtdbusversion-rb.hpp"
+#include <qtdbusversion.h>
+
+using namespace Rice;
+
+void Init_qtdbusversion(Rice::Module rb_mQt6QtDBus)
+{
+    rb_mQt6QtDBus.define_constant("QTDBUS_VERSION", QTDBUS_VERSION_STR);
+}

data/ext/qt6/qtdbus/qtdbusversion-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qtdbusversion(Rice::Module rb_mQt6QtDBus);

data/ext/qt6/qtdbus/t-qtdbus-rb.cpp

@@ -0,0 +1,12 @@
+#include "t-qtdbus-rb.hpp"
+#include <rice/qt6/qdbusreply.hpp>
+
+#include <QList>
+
+using namespace Rice;
+
+void Init_t_qtdbus(Rice::Module rb_mQt6T)
+{
+    // QDBusReply<QList<QString>>
+    define_qdbusreply_under<QList<QString>>(rb_mQt6T);
+}

data/ext/qt6/qtdbus/t-qtdbus-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_t_qtdbus(Rice::Module rb_mQt6T);

data/lib/qt6/bando/qdbusabstractadaptor.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module Bando
+    class QDBusAbstractAdaptor < RubyQt6::QtDBus::QDBusAbstractAdaptor
+      Bando.define_bando_qobject Bando::QDBusAbstractAdaptor
+    end
+  end
+end

data/lib/qt6/bando/qdbusabstractinterface.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module Bando
+    class QDBusAbstractInterface < RubyQt6::QtDBus::QDBusAbstractInterface
+      Bando.define_bando_qobject Bando::QDBusAbstractInterface
+    end
+  end
+end

data/lib/qt6/qtdbus/qdbus.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+    module QDBus
+      # @!parse class CallMode; end
+      rubyqt6_declare_enum_under QDBus, QDBus::CallMode
+    end
+  end
+end

data/lib/qt6/qtdbus/qdbusabstractadaptor.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+    # @see https://doc.qt.io/qt-6/qdbusabstractadaptor.html
+    class QDBusAbstractAdaptor < RubyQt6::QtCore::QObject
+      # @!parse
+      q_object do
+      end
+
+      # @param parent [QObject]
+      # @return [QDBusAbstractAdaptor]
+      def initialize(parent = nil)
+        _initialize(parent)
+        _take_ownership_from_ruby(self)
+      end
+    end
+  end
+end

data/lib/qt6/qtdbus/qdbusabstractinterface.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+    # @see https://doc.qt.io/qt-6/qdbusabstractinterface.html
+    class QDBusAbstractInterface < RubyQt6::QtCore::QObject
+      # @!parse
+      q_object do
+      end
+
+      # @param service [String, QString]
+      # @param path [String, QString]
+      # @param interface [String]
+      # @param connection [QDBusConnection]
+      # @param parent [QObject]
+      # @return [QDBusAbstractInterface]
+      def initialize(service, path, interface, connection, parent = nil)
+        _initialize(T.to_qstr(service), T.to_qstr(path), interface, connection, parent)
+        _take_ownership_from_ruby(self)
+      end
+
+      # @!visibility private
+      def async_call(method, *args)
+        async_call_with_argument_list(T.to_qstr(method), T.to_qvariantlist(args))
+      end
+
+      # @!visibility private
+      def call(*args)
+        mode = args_nth_delete_callmode(args, 0) || QtDBus::QDBus::CallMode::AutoDetect
+        method = args.delete_at(0)
+        call_with_argument_list(mode, T.to_qstr(method), T.to_qvariantlist(args))
+      end
+
+      private
+
+      def args_nth_delete_callmode(args, index)
+        return unless args[index].is_a?(QtDBus::QDBus::CallMode)
+        args.delete_at(index)
+      end
+    end
+  end
+end

data/lib/qt6/qtdbus/qdbusconnection.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+    # @see https://doc.qt.io/qt-6/qdbusconnection.html
+    class QDBusConnection
+      # @!parse class BusType               ; end
+      # @!parse class RegisterOption        ; end
+      # @!parse class RegisterOptions       ; end
+      # @!parse class UnregisterMode        ; end
+      # @!parse class ConnectionCapability  ; end
+      # @!parse class ConnectionCapabilities; end
+      rubyqt6_declare_enum_under QDBusConnection, QDBusConnection::BusType
+      rubyqt6_declare_enum_under QDBusConnection, QDBusConnection::RegisterOption
+      rubyqt6_declare_enum_under QDBusConnection, QDBusConnection::UnregisterMode
+      rubyqt6_declare_enum_under QDBusConnection, QDBusConnection::ConnectionCapability
+      rubyqt6_declare_qflags QDBusConnection::ConnectionCapabilities, QDBusConnection::ConnectionCapability
+      rubyqt6_declare_qflags QDBusConnection::RegisterOptions, QDBusConnection::RegisterOption
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param name [String, QString]
+      # @return [QDBusMessage]
+      def initialize(name)
+        _initialize(T.to_qstr(name))
+      end
+
+      # @!visibility private
+      def register_object(*args)
+        options = args_nth_delete_registeroptions(args, -1) || QtDBus::QDBusConnection::RegisterOption::ExportAdaptors
+        case args.size
+        when 2 then _register_object(T.to_qstr(args[-2]), args[-1], T.to_qflags(options))
+        when 3 then _register_object(T.to_qstr(args[-3]), T.to_qstr(args[-2]), args[-1], T.to_qflags(options))
+        else _register_object(*args)
+        end
+      end
+
+      # @!visibility private
+      def register_service(service_name)
+        _register_service(T.to_qstr(service_name))
+      end
+
+      private
+
+      def args_nth_delete_registeroptions(args, index)
+        return unless args[index].is_a?(QtDBus::QDBusConnection::RegisterOption) || args[index].is_a?(QtDBus::QDBusConnection::RegisterOptions)
+        args.delete_at(index)
+      end
+    end
+  end
+end

data/lib/qt6/qtdbus/qdbusconnectioninterface.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+    # @see https://doc.qt.io/qt-6/qdbusconnectioninterface.html
+    class QDBusConnectionInterface < RubyQt6::QtDBus::QDBusAbstractInterface
+      # @!parse class ServiceQueueOptions      ; end
+      # @!parse class ServiceReplacementOptions; end
+      # @!parse class RegisterServiceReply     ; end
+      rubyqt6_declare_enum_under QDBusConnectionInterface, QDBusConnectionInterface::ServiceQueueOptions
+      rubyqt6_declare_enum_under QDBusConnectionInterface, QDBusConnectionInterface::ServiceReplacementOptions
+      rubyqt6_declare_enum_under QDBusConnectionInterface, QDBusConnectionInterface::RegisterServiceReply
+
+      # @!parse
+      q_object do
+        signal "callWithCallbackFailed(QDBusError,QDBusMessage)"
+        signal "serviceRegistered(QString)"
+        signal "serviceUnregistered(QString)"
+      end
+    end
+  end
+end

data/lib/qt6/qtdbus/qdbuserror.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+    # @see https://doc.qt.io/qt-6/qdbuserror.html
+    class QDBusError
+      # @!parse class ErrorType; end
+      rubyqt6_declare_enum_under QDBusError, QDBusError::ErrorType
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QDBusError]
+      #
+      # @overload initialize(message)
+      #   @param message [QDBusMessage]
+      #
+      # @overload initialize(type, message)
+      #   @param type [QDBusError::ErrorType]
+      #   @param message [String, QString]
+      def initialize(*args)
+        _initialize(*args)
+      end
+    end
+  end
+end

data/lib/qt6/qtdbus/qdbusinterface.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+    # @see https://doc.qt.io/qt-6/qdbusinterface.html
+    class QDBusInterface < RubyQt6::QtDBus::QDBusAbstractInterface
+      # @!parse
+      q_object do
+      end
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param service [String, QString]
+      # @param path [String, QString]
+      # @param interface [String, QString]
+      # @param connection [QDBusConnection]
+      # @param parent [QObject]
+      # @return [QDBusInterface]
+      def initialize(service, path, interface = "", connection = nil, parent = nil)
+        _initialize(T.to_qstr(service), T.to_qstr(path), T.to_qstr(interface), connection || QtDBus::QDBusConnection.session_bus, parent)
+        _take_ownership_from_ruby(self)
+      end
+    end
+  end
+end

data/lib/qt6/qtdbus/qdbusmessage.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+    # @see https://doc.qt.io/qt-6/qdbusmessage.html
+    class QDBusMessage
+      # @!parse class MessageType; end
+      rubyqt6_declare_enum_under QDBusMessage, QDBusMessage::MessageType
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @!visibility private
+      def self.create_method_call(destination, path, interface, method)
+        _create_method_call(T.to_qstr(destination), T.to_qstr(path), T.to_qstr(interface), T.to_qstr(method))
+      end
+
+      # @!visibility private
+      def self.create_signal(path, interface, name)
+        _create_signal(T.to_qstr(path), T.to_qstr(interface), T.to_qstr(name))
+      end
+
+      # @!visibility private
+      def self.create_targeted_signal(service, path, interface, name)
+        _create_targeted_signal(T.to_qstr(service), T.to_qstr(path), T.to_qstr(interface), T.to_qstr(name))
+      end
+
+      # @return [QDBusMessage]
+      def initialize
+        _initialize
+      end
+
+      # @!visibility private
+      def set_arguments(*args)
+        _set_arguments(T.to_qvariantlist(args))
+      end
+    end
+  end
+end

data/lib/qt6/qtdbus/qdbusreply.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+    # @see https://doc.qt.io/qt-6/qdbusreply.html
+    class QDBusReply
+      # @!visibility private
+      attr_reader :error
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param message [QDBusMessage]
+      # @return [QDBusReply]
+      def initialize(message)
+        @error = QtDBus::QDBusError.new(message)
+        if @error.valid?
+          @data = QtCore::QVariant.new("")
+          return
+        end
+
+        if message.arguments.size < 1
+          @error = QtDBus::QDBusError.new(QtDBus::QDBusError::ErrorType::InvalidSignature, "Unexpected reply signature")
+          @data = QtCore::QVariant.new("")
+          return
+        end
+
+        @data = message.arguments[0]
+      end
+
+      # @!visibility private
+      def valid?
+        !@error.valid?
+      end
+
+      # @!visibility private
+      def value
+        valid? ? @data.value : nil
+      end
+    end
+  end
+end

data/lib/qt6/qtdbus/qdbusservicewatcher.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+    # @see https://doc.qt.io/qt-6/qdbusservicewatcher.html
+    class QDBusServiceWatcher < RubyQt6::QtCore::QObject
+      # @!parse class WatchModeFlag; end
+      # @!parse class WatchMode    ; end
+      rubyqt6_declare_enum_under QDBusServiceWatcher, QDBusServiceWatcher::WatchModeFlag
+      rubyqt6_declare_qflags QDBusServiceWatcher::WatchMode, QDBusServiceWatcher::WatchModeFlag
+
+      # @!parse
+      q_object do
+        signal "serviceOwnerChanged(QString,QString,QString)"
+        signal "serviceRegistered(QString)"
+        signal "serviceUnregistered(QString)"
+      end
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param parent [QObject]
+      # @return [QDBusServiceWatcher]
+      def initialize(parent = nil)
+        _initialize(parent)
+        _take_ownership_from_ruby(self)
+      end
+
+      # @!visibility private
+      def add_watched_service(new_service)
+        _add_watched_service(T.to_qstr(new_service))
+      end
+    end
+  end
+end

data/lib/qt6/qtdbus/qdbusvariant.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+    # @see https://doc.qt.io/qt-6/qdbusvariant.html
+    class QDBusVariant
+      # @!parse
+      QtCore::QVariant.register(_qvariant_register_metatype, method(:_qvariant_from_value), method(:_qvariant_to_value), from: self)
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param variant [QVariant]
+      # @return [QDBusVariant]
+      def initialize(variant)
+        variant = variant.is_a?(QtCore::QVariant) ? variant : QtCore::QVariant.new(variant)
+        _initialize(variant)
+      end
+    end
+  end
+end

data/lib/qt6/qtdbus/qtdbusversion.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+  end
+end

data/lib/qt6/qtdbus/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtDBus
+    QTDBUS_RUBYGEM_VERSION = "1.0.0"
+  end
+end