diff --git a/TESTS/events/queue/main.cpp b/TESTS/events/queue/main.cpp
index bdb58b6eda..b48c3d6994 100644
--- a/TESTS/events/queue/main.cpp
+++ b/TESTS/events/queue/main.cpp
@@ -210,7 +210,7 @@ void event_class_helper_test() {
 
 void event_inference_test() {
     counter = 0;
-    EventQueue queue (2048);
+    EventQueue queue(2048);
 
     queue.event(count5, 1, 1, 1, 1, 1).post();
     queue.event(count5, 1, 1, 1, 1).post(1);
@@ -219,9 +219,16 @@ void event_inference_test() {
     queue.event(count5, 1).post(1, 1, 1, 1);
     queue.event(count5).post(1, 1, 1, 1, 1);
 
+    queue.event(callback(count5), 1, 1, 1, 1, 1).post();
+    queue.event(callback(count5), 1, 1, 1, 1).post(1);
+    queue.event(callback(count5), 1, 1, 1).post(1, 1);
+    queue.event(callback(count5), 1, 1).post(1, 1, 1);
+    queue.event(callback(count5), 1).post(1, 1, 1, 1);
+    queue.event(callback(count5)).post(1, 1, 1, 1, 1);
+
     queue.dispatch(0);
 
-    TEST_ASSERT_EQUAL(counter, 30);
+    TEST_ASSERT_EQUAL(counter, 60);
 }
 
 
diff --git a/events/Event.h b/events/Event.h
index db4b0d76bf..7ddf9183f7 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -2417,6 +2417,11 @@ Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)() const vo
     return Event<void()>(this, mbed::callback(obj, method));
 }
 
+template <typename R>
+Event<void()> EventQueue::event(mbed::Callback<R()> cb) {
+    return Event<void()>(this, cb);
+}
+
 template <typename R, typename B0, typename C0>
 Event<void()> EventQueue::event(R (*func)(B0), C0 c0) {
     return Event<void()>(this, func, c0);
@@ -2442,6 +2447,11 @@ Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)(B0) const
     return Event<void()>(this, mbed::callback(obj, method), c0);
 }
 
+template <typename R, typename B0, typename C0>
+Event<void()> EventQueue::event(mbed::Callback<R(B0)> cb, C0 c0) {
+    return Event<void()>(this, cb, c0);
+}
+
 template <typename R, typename B0, typename B1, typename C0, typename C1>
 Event<void()> EventQueue::event(R (*func)(B0, B1), C0 c0, C1 c1) {
     return Event<void()>(this, func, c0, c1);
@@ -2467,6 +2477,11 @@ Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1) co
     return Event<void()>(this, mbed::callback(obj, method), c0, c1);
 }
 
+template <typename R, typename B0, typename B1, typename C0, typename C1>
+Event<void()> EventQueue::event(mbed::Callback<R(B0, B1)> cb, C0 c0, C1 c1) {
+    return Event<void()>(this, cb, c0, c1);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
 Event<void()> EventQueue::event(R (*func)(B0, B1, B2), C0 c0, C1 c1, C2 c2) {
     return Event<void()>(this, func, c0, c1, c2);
@@ -2492,6 +2507,11 @@ Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2
     return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
+Event<void()> EventQueue::event(mbed::Callback<R(B0, B1, B2)> cb, C0 c0, C1 c1, C2 c2) {
+    return Event<void()>(this, cb, c0, c1, c2);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
 Event<void()> EventQueue::event(R (*func)(B0, B1, B2, B3), C0 c0, C1 c1, C2 c2, C3 c3) {
     return Event<void()>(this, func, c0, c1, c2, c3);
@@ -2517,6 +2537,11 @@ Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2
     return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
+Event<void()> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3)> cb, C0 c0, C1 c1, C2 c2, C3 c3) {
+    return Event<void()>(this, cb, c0, c1, c2, c3);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
 Event<void()> EventQueue::event(R (*func)(B0, B1, B2, B3, B4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
     return Event<void()>(this, func, c0, c1, c2, c3, c4);
@@ -2542,6 +2567,11 @@ Event<void()> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1, B2
     return Event<void()>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
+Event<void()> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
+    return Event<void()>(this, cb, c0, c1, c2, c3, c4);
+}
+
 template <typename R, typename A0>
 Event<void(A0)> EventQueue::event(R (*func)(A0)) {
     return Event<void(A0)>(this, func);
@@ -2567,6 +2597,11 @@ Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(A0) cons
     return Event<void(A0)>(this, mbed::callback(obj, method));
 }
 
+template <typename R, typename A0>
+Event<void(A0)> EventQueue::event(mbed::Callback<R(A0)> cb) {
+    return Event<void(A0)>(this, cb);
+}
+
 template <typename R, typename B0, typename C0, typename A0>
 Event<void(A0)> EventQueue::event(R (*func)(B0, A0), C0 c0) {
     return Event<void(A0)>(this, func, c0);
@@ -2592,6 +2627,11 @@ Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, A0)
     return Event<void(A0)>(this, mbed::callback(obj, method), c0);
 }
 
+template <typename R, typename B0, typename C0, typename A0>
+Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, A0)> cb, C0 c0) {
+    return Event<void(A0)>(this, cb, c0);
+}
+
 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
 Event<void(A0)> EventQueue::event(R (*func)(B0, B1, A0), C0 c0, C1 c1) {
     return Event<void(A0)>(this, func, c0, c1);
@@ -2617,6 +2657,11 @@ Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1,
     return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1);
 }
 
+template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
+Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, A0)> cb, C0 c0, C1 c1) {
+    return Event<void(A0)>(this, cb, c0, c1);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
 Event<void(A0)> EventQueue::event(R (*func)(B0, B1, B2, A0), C0 c0, C1 c1, C2 c2) {
     return Event<void(A0)>(this, func, c0, c1, c2);
@@ -2642,6 +2687,11 @@ Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1,
     return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
+Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0)> cb, C0 c0, C1 c1, C2 c2) {
+    return Event<void(A0)>(this, cb, c0, c1, c2);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
 Event<void(A0)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0), C0 c0, C1 c1, C2 c2, C3 c3) {
     return Event<void(A0)>(this, func, c0, c1, c2, c3);
@@ -2667,6 +2717,11 @@ Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1,
     return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
+Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3) {
+    return Event<void(A0)>(this, cb, c0, c1, c2, c3);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
 Event<void(A0)> EventQueue::event(R (*func)(B0, B1, B2, B3, B4, A0), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
     return Event<void(A0)>(this, func, c0, c1, c2, c3, c4);
@@ -2692,6 +2747,11 @@ Event<void(A0)> EventQueue::event(const volatile T *obj, R (T::*method)(B0, B1,
     return Event<void(A0)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
+Event<void(A0)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
+    return Event<void(A0)>(this, cb, c0, c1, c2, c3, c4);
+}
+
 template <typename R, typename A0, typename A1>
 Event<void(A0, A1)> EventQueue::event(R (*func)(A0, A1)) {
     return Event<void(A0, A1)>(this, func);
@@ -2717,6 +2777,11 @@ Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(A0,
     return Event<void(A0, A1)>(this, mbed::callback(obj, method));
 }
 
+template <typename R, typename A0, typename A1>
+Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(A0, A1)> cb) {
+    return Event<void(A0, A1)>(this, cb);
+}
+
 template <typename R, typename B0, typename C0, typename A0, typename A1>
 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, A0, A1), C0 c0) {
     return Event<void(A0, A1)>(this, func, c0);
@@ -2742,6 +2807,11 @@ Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(B0,
     return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0);
 }
 
+template <typename R, typename B0, typename C0, typename A0, typename A1>
+Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, A0, A1)> cb, C0 c0) {
+    return Event<void(A0, A1)>(this, cb, c0);
+}
+
 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, B1, A0, A1), C0 c0, C1 c1) {
     return Event<void(A0, A1)>(this, func, c0, c1);
@@ -2767,6 +2837,11 @@ Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(B0,
     return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1);
 }
 
+template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
+Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1)> cb, C0 c0, C1 c1) {
+    return Event<void(A0, A1)>(this, cb, c0, c1);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, B1, B2, A0, A1), C0 c0, C1 c1, C2 c2) {
     return Event<void(A0, A1)>(this, func, c0, c1, c2);
@@ -2792,6 +2867,11 @@ Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(B0,
     return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
+Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1)> cb, C0 c0, C1 c1, C2 c2) {
+    return Event<void(A0, A1)>(this, cb, c0, c1, c2);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3) {
     return Event<void(A0, A1)>(this, func, c0, c1, c2, c3);
@@ -2817,6 +2897,11 @@ Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(B0,
     return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
+Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3) {
+    return Event<void(A0, A1)>(this, cb, c0, c1, c2, c3);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
 Event<void(A0, A1)> EventQueue::event(R (*func)(B0, B1, B2, B3, B4, A0, A1), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
     return Event<void(A0, A1)>(this, func, c0, c1, c2, c3, c4);
@@ -2842,6 +2927,11 @@ Event<void(A0, A1)> EventQueue::event(const volatile T *obj, R (T::*method)(B0,
     return Event<void(A0, A1)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
+Event<void(A0, A1)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
+    return Event<void(A0, A1)>(this, cb, c0, c1, c2, c3, c4);
+}
+
 template <typename R, typename A0, typename A1, typename A2>
 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(A0, A1, A2)) {
     return Event<void(A0, A1, A2)>(this, func);
@@ -2867,6 +2957,11 @@ Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R (T::*method)(
     return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method));
 }
 
+template <typename R, typename A0, typename A1, typename A2>
+Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(A0, A1, A2)> cb) {
+    return Event<void(A0, A1, A2)>(this, cb);
+}
+
 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, A0, A1, A2), C0 c0) {
     return Event<void(A0, A1, A2)>(this, func, c0);
@@ -2892,6 +2987,11 @@ Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R (T::*method)(
     return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0);
 }
 
+template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
+Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, A0, A1, A2)> cb, C0 c0) {
+    return Event<void(A0, A1, A2)>(this, cb, c0);
+}
+
 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, B1, A0, A1, A2), C0 c0, C1 c1) {
     return Event<void(A0, A1, A2)>(this, func, c0, c1);
@@ -2917,6 +3017,11 @@ Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R (T::*method)(
     return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1);
 }
 
+template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
+Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1, A2)> cb, C0 c0, C1 c1) {
+    return Event<void(A0, A1, A2)>(this, cb, c0, c1);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, B1, B2, A0, A1, A2), C0 c0, C1 c1, C2 c2) {
     return Event<void(A0, A1, A2)>(this, func, c0, c1, c2);
@@ -2942,6 +3047,11 @@ Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R (T::*method)(
     return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
+Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2) {
+    return Event<void(A0, A1, A2)>(this, cb, c0, c1, c2);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3) {
     return Event<void(A0, A1, A2)>(this, func, c0, c1, c2, c3);
@@ -2967,6 +3077,11 @@ Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R (T::*method)(
     return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
+Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3) {
+    return Event<void(A0, A1, A2)>(this, cb, c0, c1, c2, c3);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
 Event<void(A0, A1, A2)> EventQueue::event(R (*func)(B0, B1, B2, B3, B4, A0, A1, A2), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
     return Event<void(A0, A1, A2)>(this, func, c0, c1, c2, c3, c4);
@@ -2992,6 +3107,11 @@ Event<void(A0, A1, A2)> EventQueue::event(const volatile T *obj, R (T::*method)(
     return Event<void(A0, A1, A2)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
+Event<void(A0, A1, A2)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
+    return Event<void(A0, A1, A2)>(this, cb, c0, c1, c2, c3, c4);
+}
+
 template <typename R, typename A0, typename A1, typename A2, typename A3>
 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(A0, A1, A2, A3)) {
     return Event<void(A0, A1, A2, A3)>(this, func);
@@ -3017,6 +3137,11 @@ Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R (T::*meth
     return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method));
 }
 
+template <typename R, typename A0, typename A1, typename A2, typename A3>
+Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(A0, A1, A2, A3)> cb) {
+    return Event<void(A0, A1, A2, A3)>(this, cb);
+}
+
 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, A0, A1, A2, A3), C0 c0) {
     return Event<void(A0, A1, A2, A3)>(this, func, c0);
@@ -3042,6 +3167,11 @@ Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R (T::*meth
     return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0);
 }
 
+template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
+Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, A0, A1, A2, A3)> cb, C0 c0) {
+    return Event<void(A0, A1, A2, A3)>(this, cb, c0);
+}
+
 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, B1, A0, A1, A2, A3), C0 c0, C1 c1) {
     return Event<void(A0, A1, A2, A3)>(this, func, c0, c1);
@@ -3067,6 +3197,11 @@ Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R (T::*meth
     return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1);
 }
 
+template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
+Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1, A2, A3)> cb, C0 c0, C1 c1) {
+    return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, B1, B2, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2) {
     return Event<void(A0, A1, A2, A3)>(this, func, c0, c1, c2);
@@ -3092,6 +3227,11 @@ Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R (T::*meth
     return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
+Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2) {
+    return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1, c2);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3) {
     return Event<void(A0, A1, A2, A3)>(this, func, c0, c1, c2, c3);
@@ -3117,6 +3257,11 @@ Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R (T::*meth
     return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
+Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3) {
+    return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1, c2, c3);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
 Event<void(A0, A1, A2, A3)> EventQueue::event(R (*func)(B0, B1, B2, B3, B4, A0, A1, A2, A3), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
     return Event<void(A0, A1, A2, A3)>(this, func, c0, c1, c2, c3, c4);
@@ -3142,6 +3287,11 @@ Event<void(A0, A1, A2, A3)> EventQueue::event(const volatile T *obj, R (T::*meth
     return Event<void(A0, A1, A2, A3)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
+Event<void(A0, A1, A2, A3)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
+    return Event<void(A0, A1, A2, A3)>(this, cb, c0, c1, c2, c3, c4);
+}
+
 template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(A0, A1, A2, A3, A4)) {
     return Event<void(A0, A1, A2, A3, A4)>(this, func);
@@ -3167,6 +3317,11 @@ Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const volatile T *obj, R (T::*
     return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method));
 }
 
+template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
+Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(A0, A1, A2, A3, A4)> cb) {
+    return Event<void(A0, A1, A2, A3, A4)>(this, cb);
+}
+
 template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(B0, A0, A1, A2, A3, A4), C0 c0) {
     return Event<void(A0, A1, A2, A3, A4)>(this, func, c0);
@@ -3192,6 +3347,11 @@ Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const volatile T *obj, R (T::*
     return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0);
 }
 
+template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
+Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(B0, A0, A1, A2, A3, A4)> cb, C0 c0) {
+    return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0);
+}
+
 template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(B0, B1, A0, A1, A2, A3, A4), C0 c0, C1 c1) {
     return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1);
@@ -3217,6 +3377,11 @@ Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const volatile T *obj, R (T::*
     return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1);
 }
 
+template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
+Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(B0, B1, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1) {
+    return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(B0, B1, B2, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2) {
     return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1, c2);
@@ -3242,6 +3407,11 @@ Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const volatile T *obj, R (T::*
     return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
+Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2) {
+    return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1, c2);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(B0, B1, B2, B3, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3) {
     return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1, c2, c3);
@@ -3267,6 +3437,11 @@ Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const volatile T *obj, R (T::*
     return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
+Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2, C3 c3) {
+    return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1, c2, c3);
+}
+
 template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
 Event<void(A0, A1, A2, A3, A4)> EventQueue::event(R (*func)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4), C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
     return Event<void(A0, A1, A2, A3, A4)>(this, func, c0, c1, c2, c3, c4);
@@ -3292,6 +3467,11 @@ Event<void(A0, A1, A2, A3, A4)> EventQueue::event(const volatile T *obj, R (T::*
     return Event<void(A0, A1, A2, A3, A4)>(this, mbed::callback(obj, method), c0, c1, c2, c3, c4);
 }
 
+template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
+Event<void(A0, A1, A2, A3, A4)> EventQueue::event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4) {
+    return Event<void(A0, A1, A2, A3, A4)>(this, cb, c0, c1, c2, c3, c4);
+}
+
 }
 
 #endif
diff --git a/events/EventQueue.h b/events/EventQueue.h
index cf1ae22488..b9ba2a31e8 100644
--- a/events/EventQueue.h
+++ b/events/EventQueue.h
@@ -974,6 +974,12 @@ public:
     template <typename T, typename R>
     Event<void()> event(const volatile T *obj, R (T::*method)() const volatile);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R>
+    Event<void()> event(mbed::Callback<R()> cb);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1004,6 +1010,12 @@ public:
     template <typename T, typename R, typename B0, typename C0>
     Event<void()> event(const volatile T *obj, R (T::*method)(B0) const volatile, C0 c0);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename C0>
+    Event<void()> event(mbed::Callback<R(B0)> cb, C0 c0);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1034,6 +1046,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1>
     Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1) const volatile, C0 c0, C1 c1);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename C0, typename C1>
+    Event<void()> event(mbed::Callback<R(B0, B1)> cb, C0 c0, C1 c1);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1064,6 +1082,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
     Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2) const volatile, C0 c0, C1 c1, C2 c2);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2>
+    Event<void()> event(mbed::Callback<R(B0, B1, B2)> cb, C0 c0, C1 c1, C2 c2);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1094,6 +1118,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
     Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3>
+    Event<void()> event(mbed::Callback<R(B0, B1, B2, B3)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1124,6 +1154,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
     Event<void()> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4>
+    Event<void()> event(mbed::Callback<R(B0, B1, B2, B3, B4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1154,6 +1190,12 @@ public:
     template <typename T, typename R, typename A0>
     Event<void(A0)> event(const volatile T *obj, R (T::*method)(A0) const volatile);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename A0>
+    Event<void(A0)> event(mbed::Callback<R(A0)> cb);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1184,6 +1226,12 @@ public:
     template <typename T, typename R, typename B0, typename C0, typename A0>
     Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, A0) const volatile, C0 c0);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename C0, typename A0>
+    Event<void(A0)> event(mbed::Callback<R(B0, A0)> cb, C0 c0);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1214,6 +1262,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
     Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, A0) const volatile, C0 c0, C1 c1);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0>
+    Event<void(A0)> event(mbed::Callback<R(B0, B1, A0)> cb, C0 c0, C1 c1);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1244,6 +1298,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
     Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0) const volatile, C0 c0, C1 c1, C2 c2);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0>
+    Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, A0)> cb, C0 c0, C1 c1, C2 c2);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1274,6 +1334,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
     Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0>
+    Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, B3, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1304,6 +1370,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
     Event<void(A0)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0>
+    Event<void(A0)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1334,6 +1406,12 @@ public:
     template <typename T, typename R, typename A0, typename A1>
     Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(A0, A1) const volatile);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename A0, typename A1>
+    Event<void(A0, A1)> event(mbed::Callback<R(A0, A1)> cb);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1364,6 +1442,12 @@ public:
     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1>
     Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, A0, A1) const volatile, C0 c0);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename C0, typename A0, typename A1>
+    Event<void(A0, A1)> event(mbed::Callback<R(B0, A0, A1)> cb, C0 c0);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1394,6 +1478,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
     Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1) const volatile, C0 c0, C1 c1);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1>
+    Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, A0, A1)> cb, C0 c0, C1 c1);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1424,6 +1514,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
     Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1) const volatile, C0 c0, C1 c1, C2 c2);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1>
+    Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, A0, A1)> cb, C0 c0, C1 c1, C2 c2);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1454,6 +1550,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
     Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1>
+    Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1484,6 +1586,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
     Event<void(A0, A1)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1>
+    Event<void(A0, A1)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1514,6 +1622,12 @@ public:
     template <typename T, typename R, typename A0, typename A1, typename A2>
     Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(A0, A1, A2) const volatile);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename A0, typename A1, typename A2>
+    Event<void(A0, A1, A2)> event(mbed::Callback<R(A0, A1, A2)> cb);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1544,6 +1658,12 @@ public:
     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
     Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2) const volatile, C0 c0);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2>
+    Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, A0, A1, A2)> cb, C0 c0);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1574,6 +1694,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
     Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2) const volatile, C0 c0, C1 c1);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2>
+    Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, A0, A1, A2)> cb, C0 c0, C1 c1);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1604,6 +1730,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
     Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2>
+    Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1634,6 +1766,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
     Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2>
+    Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1664,6 +1802,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
     Event<void(A0, A1, A2)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2>
+    Event<void(A0, A1, A2)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1694,6 +1838,12 @@ public:
     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3>
     Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3) const volatile);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename A0, typename A1, typename A2, typename A3>
+    Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(A0, A1, A2, A3)> cb);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1724,6 +1874,12 @@ public:
     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
     Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3) const volatile, C0 c0);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3>
+    Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, A0, A1, A2, A3)> cb, C0 c0);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1754,6 +1910,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
     Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3) const volatile, C0 c0, C1 c1);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3>
+    Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, A0, A1, A2, A3)> cb, C0 c0, C1 c1);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1784,6 +1946,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
     Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3>
+    Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1814,6 +1982,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
     Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3>
+    Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1844,6 +2018,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
     Event<void(A0, A1, A2, A3)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3>
+    Event<void(A0, A1, A2, A3)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2, A3)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1874,6 +2054,12 @@ public:
     template <typename T, typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
     Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(A0, A1, A2, A3, A4) const volatile);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
+    Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(A0, A1, A2, A3, A4)> cb);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1904,6 +2090,12 @@ public:
     template <typename T, typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
     Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, A0, A1, A2, A3, A4) const volatile, C0 c0);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename C0, typename A0, typename A1, typename A2, typename A3, typename A4>
+    Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, A0, A1, A2, A3, A4)> cb, C0 c0);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1934,6 +2126,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
     Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, B1, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename C0, typename C1, typename A0, typename A1, typename A2, typename A3, typename A4>
+    Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1964,6 +2162,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
     Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename C0, typename C1, typename C2, typename A0, typename A1, typename A2, typename A3, typename A4>
+    Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, B2, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -1994,6 +2198,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
     Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2, C3 c3);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename B3, typename C0, typename C1, typename C2, typename C3, typename A0, typename A1, typename A2, typename A3, typename A4>
+    Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, B2, B3, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2, C3 c3);
+
     /** Creates an event bound to the event queue
      *  @see EventQueue::event
      */
@@ -2024,6 +2234,12 @@ public:
     template <typename T, typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
     Event<void(A0, A1, A2, A3, A4)> event(const volatile T *obj, R (T::*method)(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4) const volatile, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
 
+    /** Creates an event bound to the event queue
+     *  @see EventQueue::event
+     */
+    template <typename R, typename B0, typename B1, typename B2, typename B3, typename B4, typename C0, typename C1, typename C2, typename C3, typename C4, typename A0, typename A1, typename A2, typename A3, typename A4>
+    Event<void(A0, A1, A2, A3, A4)> event(mbed::Callback<R(B0, B1, B2, B3, B4, A0, A1, A2, A3, A4)> cb, C0 c0, C1 c1, C2 c2, C3 c3, C4 c4);
+
 protected:
     template <typename F>
     friend class Event;