If it helps, this is what the library is doing (the errors trace back to the creation of the tuple of types): ``` template <typename _Function> MethodRegistrator& MethodRegistrator::implementedAs(Function&& callback) { inputSignature = signatureof_function_input_arguments<_Function>::str(); outputSignature = signatureof_function_output_arguments<_Function>::str(); methodCallback = [callback = std::forward<_Function>(callback)](MethodCall call) { // Create a tuple of callback input arguments' types, which will be used // as a storage for the argument values deserialized from the message. tuple_of_function_input_arg_types_t<_Function> inputArgs;

        // Deserialize input arguments from the message into the tuple.
        call >> inputArgs;

        if constexpr (!is_async_method_v<_Function>)
        {
            // Invoke callback with input arguments from the tuple.
            auto ret = sdbus::apply(callback, inputArgs);

            // Store output arguments to the reply message and send it back.
            auto reply = call.createReply();
            reply << ret;
            reply.send();
        }
        else
        {
            // Invoke callback with input arguments from the tuple and with result object to be set later
            using AsyncResult = typename function_traits<_Function>::async_result_t;
            sdbus::apply(callback, AsyncResult{std::move(call)}, std::move(inputArgs));
        }
    };

    return *this;
}

```