diff --git a/harness/tests/src/main/java/godot/tests/JavaTestClass.java b/harness/tests/src/main/java/godot/tests/JavaTestClass.java
index 663bbce5c..a20712010 100644
--- a/harness/tests/src/main/java/godot/tests/JavaTestClass.java
+++ b/harness/tests/src/main/java/godot/tests/JavaTestClass.java
@@ -10,11 +10,11 @@
 
 @RegisterClass
 public class JavaTestClass extends Node {
-    @RegisterSignal
-    public Signal0 testSignal = Signal0.create(this, "test_signal");
-
-    @RegisterSignal(parameters = {"param1", "param2"})
-    public Signal2<String, String> testSignal2 = Signal2.create(this, "test_signal_2");
+    //@RegisterSignal
+    //public Signal0 testSignal = Signal0.create(this, "test_signal");
+//
+    //@RegisterSignal(parameters = {"param1", "param2"})
+    //public Signal2<String, String> testSignal2 = Signal2.create(this, "test_signal_2");
 
     // The following should NOT work as we cannot extract parameter names. The compiler checks should catch that and throw a build error
 //    @RegisterSignal
@@ -71,15 +71,15 @@ public String greeting() {
     @RegisterProperty
     public Dictionary<Float, String> dictionary = new Dictionary<>(Float.class, String.class);
 
-    public LambdaCallable<Void> lambdaCallable = LambdaCallable0.create(
-            Void.class,
-            () -> {
-                System.out.println("Hello from Callable");
-                return null;
-            }
-    );
-
-    public NativeCallable methodCallable = Callable.create(this, StringNames.asStringName("DummyName"));
+    //public LambdaCallable<Void> lambdaCallable = LambdaCallable0.create(
+    //        Void.class,
+    //        () -> {
+    //            System.out.println("Hello from Callable");
+    //            return null;
+    //        }
+    //);
+//
+    //public NativeCallable methodCallable = Callable.create(this, StringNames.asStringName("DummyName"));
 
     @RegisterFunction
     @Override
@@ -96,12 +96,12 @@ public void _ready() {
 
     @RegisterFunction
     public void connectAndTriggerSignal() {
-        connect(
-                StringNames.asStringName("test_signal"),
-                new NativeCallable(this, StringNames.asStringName("signal_callback")),
-                (int) ConnectFlags.ONE_SHOT.getId()
-        );
-        emitSignal(StringNames.asStringName("test_signal"));
+        //connect(
+        //        StringNames.asStringName("test_signal"),
+        //        new NativeCallable(this, StringNames.asStringName("signal_callback")),
+        //        (int) ConnectFlags.ONE_SHOT.getId()
+        //);
+        //emitSignal(StringNames.asStringName("test_signal"));
     }
 
     @NotNull
diff --git a/harness/tests/src/main/kotlin/godot/tests/FuncRefTest.kt b/harness/tests/src/main/kotlin/godot/tests/FuncRefTest.kt
index f6a0b33ed..7c1582c93 100644
--- a/harness/tests/src/main/kotlin/godot/tests/FuncRefTest.kt
+++ b/harness/tests/src/main/kotlin/godot/tests/FuncRefTest.kt
@@ -6,9 +6,10 @@ import godot.annotation.RegisterFunction
 import godot.annotation.RegisterProperty
 import godot.annotation.RegisterSignal
 import godot.annotation.Rpc
+import godot.core.callable0
+import godot.core.callable1
 import godot.core.signal0
-import godot.extension.call
-import godot.extension.callDeferred
+import godot.extension.connectMethod
 
 @RegisterClass
 class FuncRefTest : Node() {
@@ -30,7 +31,7 @@ class FuncRefTest : Node() {
 
     @RegisterFunction
     override fun _ready() {
-        test.connect(this, FuncRefTest::testSignalCallback)
+        test.connectMethod(this, FuncRefTest::testSignalCallback)
     }
 
     @Rpc
@@ -51,12 +52,12 @@ class FuncRefTest : Node() {
 
     @RegisterFunction
     fun testCallWithoutParam() {
-        call(this::withoutParamCallback)
+        callable0(this::withoutParamCallback).call()
     }
 
     @RegisterFunction
     fun testCallDeferredWithoutParam() {
-        callDeferred(this::withoutParamCallback)
+        callable0(this::withoutParamCallback).callDeferred()
     }
 
     @RegisterFunction
@@ -66,11 +67,11 @@ class FuncRefTest : Node() {
 
     @RegisterFunction
     fun testCallWithParam() {
-        call(this::withParamCallback, true)
+        callable1(this::withParamCallback).call(true)
     }
 
     @RegisterFunction
     fun testCallDeferredWithParam() {
-        callDeferred(this::withParamCallback, true)
+        callable1(this::withParamCallback).callDeferred(true)
     }
 }
diff --git a/harness/tests/src/main/kotlin/godot/tests/GodotStaticTest.kt b/harness/tests/src/main/kotlin/godot/tests/GodotStaticTest.kt
index ed05f24a0..c841be215 100644
--- a/harness/tests/src/main/kotlin/godot/tests/GodotStaticTest.kt
+++ b/harness/tests/src/main/kotlin/godot/tests/GodotStaticTest.kt
@@ -3,7 +3,7 @@ package godot.tests
 import godot.api.Node
 import godot.api.PackedScene
 import godot.api.ResourceLoader
-import godot.extension.asStatic
+import godot.extension.api.asStatic
 
 object GodotStaticDelegateTest {
     var ref = (ResourceLoader.load("res://Spatial.tscn") as PackedScene?).asStatic()
diff --git a/harness/tests/src/main/kotlin/godot/tests/Invocation.kt b/harness/tests/src/main/kotlin/godot/tests/Invocation.kt
index 6d249d1ce..bdac36c7f 100644
--- a/harness/tests/src/main/kotlin/godot/tests/Invocation.kt
+++ b/harness/tests/src/main/kotlin/godot/tests/Invocation.kt
@@ -38,10 +38,11 @@ import godot.core.Vector2
 import godot.core.Vector3
 import godot.core.dictionaryOf
 import godot.core.variantArrayOf
-import godot.extension.getNodeAs
 import godot.registration.Range
 import godot.tests.subpackage.OtherScript
 import godot.common.util.RealT
+import godot.extension.api.getNodeAs
+import godot.extension.connectMethod
 import org.joda.time.DateTime
 
 enum class TestEnum {
@@ -370,7 +371,7 @@ class Invocation : Node3D() {
         val path = NodePath("CanvasLayer/Button")
         val getNode2 = getNodeAs<Button>(path)
 
-        (getNodeOrNull(path) as Button?)?.pressed?.connect(
+        (getNodeOrNull(path) as Button?)?.pressed?.connectMethod(
             invocation,
             OtherScript::hookNoParam
         )
diff --git a/harness/tests/src/main/kotlin/godot/tests/LambdaCallableTest.kt b/harness/tests/src/main/kotlin/godot/tests/LambdaCallableTest.kt
index 93754152c..8c87ea688 100644
--- a/harness/tests/src/main/kotlin/godot/tests/LambdaCallableTest.kt
+++ b/harness/tests/src/main/kotlin/godot/tests/LambdaCallableTest.kt
@@ -7,9 +7,9 @@ import godot.annotation.RegisterProperty
 import godot.annotation.RegisterSignal
 import godot.core.Signal3
 import godot.core.asCallable
-import godot.core.connect
 import godot.core.signal0
 import godot.core.signal3
+import godot.extension.connectLambda
 
 @RegisterClass
 class LambdaCallableTest : Node() {
@@ -40,11 +40,11 @@ class LambdaCallableTest : Node() {
 
     @RegisterFunction
     override fun _ready() {
-        signalNoParam.connect {
+        signalNoParam.connectLambda {
             hasSignalNoParamBeenTriggered = true
         }
 
-        signalWithParams.connect { p0, p1, p2 ->
+        signalWithParams.connectLambda { p0, p1, p2 ->
             signalString = p0
             signalLong = p1
             signalNode = p2
diff --git a/harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt b/harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt
index f01b363fa..672ae6865 100644
--- a/harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt
+++ b/harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt
@@ -4,8 +4,12 @@ import godot.api.Node
 import godot.annotation.RegisterClass
 import godot.annotation.RegisterFunction
 import godot.annotation.RegisterProperty
-import godot.core.NativeCallable
+import godot.core.Callable0
+import godot.core.Callable1
+import godot.core.Callable2
+import godot.core.Callable3
 import godot.core.VariantArray
+import godot.core.callable3
 import godot.core.variantArrayOf
 import godot.global.GD
 
@@ -16,22 +20,28 @@ class CallableMethodBindTest: Node() {
 
     @RegisterFunction
     fun callWithMethodWithAllBinds() {
-        NativeCallable(this, CallableMethodBindTest::readySignalMethodBindTest).bind(1, 2, 3).call()
+        val unboundCallable: Callable3<Unit, Int, Int, Int> = callable3(CallableMethodBindTest::readySignalMethodBindTest)
+        val boundCallable: Callable0<Unit> = unboundCallable.bind(1, 2, 3)
+        boundCallable.call()
     }
 
     @RegisterFunction
     fun callWithMethodWithTwoBinds() {
-        NativeCallable(this, CallableMethodBindTest::readySignalMethodBindTest).bind(2, 3).call(0)
+        val unboundCallable: Callable3<Unit, Int, Int, Int> = callable3(CallableMethodBindTest::readySignalMethodBindTest)
+        val boundCallable: Callable1<Unit, Int> = unboundCallable.bind(5, 6)
+        boundCallable.call(4)
     }
 
     @RegisterFunction
     fun callWithMethodWithOneBind() {
-        NativeCallable(this, CallableMethodBindTest::readySignalMethodBindTest).bind(3).call(0, 0)
+        val unboundCallable: Callable3<Unit, Int, Int, Int> = callable3(CallableMethodBindTest::readySignalMethodBindTest)
+        val boundCallable: Callable2<Unit, Int, Int> = unboundCallable.bind(9)
+        boundCallable.call(7, 8)
     }
 
     @RegisterFunction
     fun callWithMethodWithNoBind() {
-        NativeCallable(this, CallableMethodBindTest::readySignalMethodBindTest).bind().call(0, 0, 0)
+        callable3(CallableMethodBindTest::readySignalMethodBindTest).call(10, 11, 12)
     }
 
     @RegisterFunction
diff --git a/harness/tests/src/main/kotlin/godot/tests/coroutine/CoroutineTest.kt b/harness/tests/src/main/kotlin/godot/tests/coroutine/CoroutineTest.kt
index 585249250..be58f9412 100644
--- a/harness/tests/src/main/kotlin/godot/tests/coroutine/CoroutineTest.kt
+++ b/harness/tests/src/main/kotlin/godot/tests/coroutine/CoroutineTest.kt
@@ -124,9 +124,7 @@ class CoroutineTest : Object() {
     @RegisterFunction
     fun asyncLoadResource() {
         godotCoroutine {
-            val resource = ResourceLoader.awaitLoadAs<PackedScene>("res://Spatial.tscn") { progress ->
-                GD.print("Resource load progress: $progress")
-            }
+            val resource = ResourceLoader.awaitLoadAs<PackedScene>("res://Spatial.tscn")
 
             GD.print("Resource: $resource")
 
diff --git a/harness/tests/src/main/kotlin/godot/tests/signal/SignalTest.kt b/harness/tests/src/main/kotlin/godot/tests/signal/SignalTest.kt
index 5a3238e1f..2b7dfad49 100644
--- a/harness/tests/src/main/kotlin/godot/tests/signal/SignalTest.kt
+++ b/harness/tests/src/main/kotlin/godot/tests/signal/SignalTest.kt
@@ -11,10 +11,11 @@ import godot.core.Signal2
 import godot.core.VariantArray
 import godot.core.Vector2
 import godot.core.asStringName
-import godot.core.connect
 import godot.core.signal0
 import godot.core.signal1
 import godot.core.signal2
+import godot.extension.connectLambda
+import godot.extension.connectMethod
 import godot.tests.subpackage.OtherScript
 
 @RegisterClass
@@ -44,34 +45,34 @@ class SignalTest : Node() {
     @RegisterFunction
     override fun _ready() {
 
-        noParamSignalDelegate.connect(otherScript, OtherScript::hookNoParam)
-        oneParamSignalDelegate.connect(otherScript, OtherScript::hookOneParam)
-        twoParamSignalDelegate.connect(otherScript, OtherScript::hookTwoParam)
+        noParamSignalDelegate.connectMethod(otherScript, OtherScript::hookNoParam)
+        oneParamSignalDelegate.connectMethod(otherScript, OtherScript::hookOneParam)
+        twoParamSignalDelegate.connectMethod(otherScript, OtherScript::hookTwoParam)
 
-        noParamSignalDelegate.connect { println("noParam signal emitted") }
-        oneParamSignalDelegate.connect { b -> println("oneParam signal emitted with $b") }
-        twoParamSignalDelegate.connect { p0, p1 -> println("twoParam signal emitted with $p0 and $p1") }
+        noParamSignalDelegate.connectLambda { println("noParam signal emitted") }
+        oneParamSignalDelegate.connectLambda { b -> println("oneParam signal emitted with $b") }
+        twoParamSignalDelegate.connectLambda { p0, p1 -> println("twoParam signal emitted with $p0 and $p1") }
 
         noParamSignalDelegate.emit()
         oneParamSignalDelegate.emit(false)
         twoParamSignalDelegate.emit("My Awesome param !", this)
 
 
-        noParamSignalField.connect(otherScript, OtherScript::hookNoParam)
-        oneParamSignalField.connect(otherScript, OtherScript::hookOneParam)
-        twoParamSignalField.connect(otherScript, OtherScript::hookTwoParam)
+        noParamSignalField.connectMethod(otherScript, OtherScript::hookNoParam)
+        oneParamSignalField.connectMethod(otherScript, OtherScript::hookOneParam)
+        twoParamSignalField.connectMethod(otherScript, OtherScript::hookTwoParam)
 
-        noParamSignalField.connect { println("noParam signal emitted") }
-        oneParamSignalField.connect { b -> println("oneParam signal emitted with $b") }
-        twoParamSignalField.connect { p0, p1 -> println("twoParam signal emitted with $p0 and $p1") }
+        noParamSignalField.connectLambda { println("noParam signal emitted") }
+        oneParamSignalField.connectLambda { b -> println("oneParam signal emitted with $b") }
+        twoParamSignalField.connectLambda { p0, p1 -> println("twoParam signal emitted with $p0 and $p1") }
 
         noParamSignalField.emit()
         oneParamSignalField.emit(false)
         twoParamSignalField.emit("My Awesome param !", this)
 
 
-        signalWithMultipleTargets.connect(this, SignalTest::targetFunctionOne)
-        signalWithMultipleTargets.connect(this, SignalTest::targetFunctionTwo)
+        signalWithMultipleTargets.connectMethod(this, SignalTest::targetFunctionOne)
+        signalWithMultipleTargets.connectMethod(this, SignalTest::targetFunctionTwo)
         signalWithMultipleTargets.emit(Vector2(0, 0))
     }
 
diff --git a/harness/tests/test/unit/test_call_java_class.gd b/harness/tests/test/unit/test_call_java_class.gd
index cc3958300..813200de4 100644
--- a/harness/tests/test/unit/test_call_java_class.gd
+++ b/harness/tests/test/unit/test_call_java_class.gd
@@ -21,9 +21,9 @@ func test_field_set():
 	java_scene.free()
 
 
-func test_signal():
-	var java_scene: JavaTestClass = load("res://java_test_scene.tscn").instantiate()
-	get_tree().root.add_child(java_scene)
-	await get_tree().create_timer(1).timeout
-	java_scene.connect_and_trigger_signal()
-	assert_true(java_scene.signal_emitted, "Signal should've been emitted in java")
+#func test_signal():
+#	var java_scene: JavaTestClass = load("res://java_test_scene.tscn").instantiate()
+#	get_tree().root.add_child(java_scene)
+#	await get_tree().create_timer(1).timeout
+#	java_scene.connect_and_trigger_signal()
+#	assert_true(java_scene.signal_emitted, "Signal should've been emitted in java")
diff --git a/harness/tests/test/unit/test_callable_method_bind.gd b/harness/tests/test/unit/test_callable_method_bind.gd
index 9d899b4ff..f3fb54216 100644
--- a/harness/tests/test/unit/test_callable_method_bind.gd
+++ b/harness/tests/test/unit/test_callable_method_bind.gd
@@ -26,17 +26,17 @@ func test_method_bind_passing_correct_binds_with_one_args_provided() -> void:
 	binds_test_script.call_with_method_with_two_binds()
 	assert_eq(
 		binds_test_script.method_binds[0],
-		0,
+		4,
 		"Incorrect bind value passed"
 	)
 	assert_eq(
 		binds_test_script.method_binds[1],
-		2,
+		5,
 		"Incorrect bind value passed"
 	)
 	assert_eq(
 		binds_test_script.method_binds[2],
-		3,
+		6,
 		"Incorrect bind value passed"
 	)
 	binds_test_script.free()
@@ -46,17 +46,17 @@ func test_method_bind_passing_correct_binds_with_two_args_provided() -> void:
 	binds_test_script.call_with_method_with_one_bind()
 	assert_eq(
 		binds_test_script.method_binds[0],
-		0,
+		7,
 		"Incorrect bind value passed"
 	)
 	assert_eq(
 		binds_test_script.method_binds[1],
-		0,
+		8,
 		"Incorrect bind value passed"
 	)
 	assert_eq(
 		binds_test_script.method_binds[2],
-		3,
+		9,
 		"Incorrect bind value passed"
 	)
 	binds_test_script.free()
@@ -66,17 +66,17 @@ func test_method_bind_passing_correct_binds_with_three_args_provided() -> void:
 	binds_test_script.call_with_method_with_no_bind()
 	assert_eq(
 		binds_test_script.method_binds[0],
-		0,
+		10,
 		"Incorrect bind value passed"
 	)
 	assert_eq(
 		binds_test_script.method_binds[1],
-		0,
+		11,
 		"Incorrect bind value passed"
 	)
 	assert_eq(
 		binds_test_script.method_binds[2],
-		0,
+		12,
 		"Incorrect bind value passed"
 	)
 	binds_test_script.free()
diff --git a/harness/tests/test/unit/test_funcref.gd b/harness/tests/test/unit/test_funcref.gd
index 0627f554b..6de9ad025 100644
--- a/harness/tests/test/unit/test_funcref.gd
+++ b/harness/tests/test/unit/test_funcref.gd
@@ -2,36 +2,36 @@ extends "res://addons/gut/test.gd"
 
 
 func test_call_without_param():
-	var func_ref_test_script = FuncRefTest.new()
-	func_ref_test_script.test_call_without_param()
-	assert_true(func_ref_test_script.call_flag)
-	func_ref_test_script.free()
+    var func_ref_test_script = FuncRefTest.new()
+    func_ref_test_script.test_call_without_param()
+    assert_true(func_ref_test_script.call_flag)
+    func_ref_test_script.free()
 
 func test_call_deferred_without_param():
-	var func_ref_test_script = FuncRefTest.new()
-	func_ref_test_script.test_call_deferred_without_param()
-	await get_tree().create_timer(1).timeout
-	assert_true(func_ref_test_script.call_flag)
-	func_ref_test_script.free()
+    var func_ref_test_script = FuncRefTest.new()
+    func_ref_test_script.test_call_deferred_without_param()
+    await get_tree().create_timer(1).timeout
+    assert_true(func_ref_test_script.call_flag)
+    func_ref_test_script.free()
 
 func test_call_with_param():
-	var func_ref_test_script = FuncRefTest.new()
-	func_ref_test_script.test_call_with_param()
-	assert_true(func_ref_test_script.call_with_param_flag)
-	func_ref_test_script.free()
+    var func_ref_test_script = FuncRefTest.new()
+    func_ref_test_script.test_call_with_param()
+    assert_true(func_ref_test_script.call_with_param_flag)
+    func_ref_test_script.free()
 
 func test_call_deferred_with_param():
-	var func_ref_test_script = FuncRefTest.new()
-	func_ref_test_script.test_call_deferred_with_param()
-	await get_tree().create_timer(3).timeout
-	assert_true(func_ref_test_script.call_with_param_flag)
-	func_ref_test_script.free()
+    var func_ref_test_script = FuncRefTest.new()
+    func_ref_test_script.test_call_deferred_with_param()
+    await get_tree().create_timer(3).timeout
+    assert_true(func_ref_test_script.call_with_param_flag)
+    func_ref_test_script.free()
 
 func test_signal_call():
-	var func_ref_test_script = FuncRefTest.new()
-	get_tree().root.add_child(func_ref_test_script)
-	func_ref_test_script.test_signal_call()
-	await get_tree().create_timer(1).timeout
-	assert_true(func_ref_test_script.signal_call_flag)
-	get_tree().root.remove_child(func_ref_test_script)
-	func_ref_test_script.free()
+    var func_ref_test_script = FuncRefTest.new()
+    get_tree().root.add_child(func_ref_test_script)
+    func_ref_test_script.test_signal_call()
+    await get_tree().create_timer(1).timeout
+    assert_true(func_ref_test_script.signal_call_flag)
+    get_tree().root.remove_child(func_ref_test_script)
+    func_ref_test_script.free()
diff --git a/harness/tests/test/unit/test_signals.gd b/harness/tests/test/unit/test_signals.gd
index 16953ef44..63ef4006d 100644
--- a/harness/tests/test/unit/test_signals.gd
+++ b/harness/tests/test/unit/test_signals.gd
@@ -1,42 +1,42 @@
 extends "res://addons/gut/test.gd"
 
 func test_signal_connection_script_instantiation():
-	var script = SignalTest.new()
-	get_tree().root.add_child(script)
-	assert_eq(script.is_connected("no_param_signal_delegate", Callable(script.other_script, "hook_no_param")), true, "signal \"no_param_signal_delegate\" should be connected to \"otherScript::hook_no_param\"")
-	assert_eq(script.is_connected("one_param_signal_delegate", Callable(script.other_script, "hook_one_param")), true, "signal \"one_param_signal_delegate\" should be connected to \"otherScript::hook_one_param\"")
-	assert_eq(script.is_connected("two_param_signal_delegate", Callable(script.other_script, "hook_two_param")), true, "signal \"two_param_signal_delegate\" should be connected to \"otherScript::hook_two_param\"")
+    var script = SignalTest.new()
+    get_tree().root.add_child(script)
+    assert_eq(script.is_connected("no_param_signal_delegate", Callable(script.other_script, "hook_no_param")), true, "signal \"no_param_signal_delegate\" should be connected to \"otherScript::hook_no_param\"")
+    assert_eq(script.is_connected("one_param_signal_delegate", Callable(script.other_script, "hook_one_param")), true, "signal \"one_param_signal_delegate\" should be connected to \"otherScript::hook_one_param\"")
+    assert_eq(script.is_connected("two_param_signal_delegate", Callable(script.other_script, "hook_two_param")), true, "signal \"two_param_signal_delegate\" should be connected to \"otherScript::hook_two_param\"")
 
-	assert_eq(script.is_connected("no_param_signal_field", Callable(script.other_script, "hook_no_param")), true, "signal \"no_param_signal_field\" should be connected to \"otherScript::hook_no_param\"")
-	assert_eq(script.is_connected("one_param_signal_field", Callable(script.other_script, "hook_one_param")), true, "signal \"one_param_signal_field\" should be connected to \"otherScript::hook_one_param\"")
-	assert_eq(script.is_connected("two_param_signal_field", Callable(script.other_script, "hook_two_param")), true, "signal \"two_param_signal_field\" should be connected to \"otherScript::hook_two_param\"")
+    assert_eq(script.is_connected("no_param_signal_field", Callable(script.other_script, "hook_no_param")), true, "signal \"no_param_signal_field\" should be connected to \"otherScript::hook_no_param\"")
+    assert_eq(script.is_connected("one_param_signal_field", Callable(script.other_script, "hook_one_param")), true, "signal \"one_param_signal_field\" should be connected to \"otherScript::hook_one_param\"")
+    assert_eq(script.is_connected("two_param_signal_field", Callable(script.other_script, "hook_two_param")), true, "signal \"two_param_signal_field\" should be connected to \"otherScript::hook_two_param\"")
 
-	script.free()
+    script.free()
 
 func test_signal_connection_code():
-	var invocation_script = load("res://Spatial.tscn").instantiate()
-	get_tree().root.add_child(invocation_script)
-	assert_eq(invocation_script.button.is_connected("pressed", Callable(invocation_script.invocation, "hook_no_param")), true, "signal \"pressed\" of button should be connected to \"invocation_script.invocation::hook_no_param\"")
-	invocation_script.free()
+    var invocation_script = load("res://Spatial.tscn").instantiate()
+    get_tree().root.add_child(invocation_script)
+    assert_eq(invocation_script.button.is_connected("pressed", Callable(invocation_script.invocation, "hook_no_param")), true, "signal \"pressed\" of button should be connected to \"invocation_script.invocation::hook_no_param\"")
+    invocation_script.free()
 
 func test_signal_emitted_with_multiple_targets():
-	var script = SignalTest.new()
-	get_tree().root.add_child(script)
-	assert_eq(script.array.size(), 16)
-	assert_eq(script.array[0], Vector2(0,0))
-	assert_eq(script.array[1], Vector2(1,1))
-	assert_eq(script.array[2], Vector2(1,2))
-	assert_eq(script.array[3], Vector2(1,3))
-	assert_eq(script.array[4], Vector2(1,4))
-	assert_eq(script.array[5], Vector2(1,5))
-	assert_eq(script.array[6], Vector2(1,6))
-	assert_eq(script.array[7], Vector2(1,7))
-	assert_eq(script.array[8], Vector2(1,7))
-	assert_eq(script.array[9], Vector2(1,6))
-	assert_eq(script.array[10], Vector2(1,5))
-	assert_eq(script.array[11], Vector2(1,4))
-	assert_eq(script.array[12], Vector2(1,3))
-	assert_eq(script.array[13], Vector2(1,2))
-	assert_eq(script.array[14], Vector2(1,1))
-	assert_eq(script.array[15], Vector2(0,0))
-	script.free()
+    var script = SignalTest.new()
+    get_tree().root.add_child(script)
+    assert_eq(script.array.size(), 16)
+    assert_eq(script.array[0], Vector2(0,0))
+    assert_eq(script.array[1], Vector2(1,1))
+    assert_eq(script.array[2], Vector2(1,2))
+    assert_eq(script.array[3], Vector2(1,3))
+    assert_eq(script.array[4], Vector2(1,4))
+    assert_eq(script.array[5], Vector2(1,5))
+    assert_eq(script.array[6], Vector2(1,6))
+    assert_eq(script.array[7], Vector2(1,7))
+    assert_eq(script.array[8], Vector2(1,7))
+    assert_eq(script.array[9], Vector2(1,6))
+    assert_eq(script.array[10], Vector2(1,5))
+    assert_eq(script.array[11], Vector2(1,4))
+    assert_eq(script.array[12], Vector2(1,3))
+    assert_eq(script.array[13], Vector2(1,2))
+    assert_eq(script.array[14], Vector2(1,1))
+    assert_eq(script.array[15], Vector2(0,0))
+    script.free()
diff --git a/install_vulkan_sdk_macos.sh b/install_vulkan_sdk_macos.sh
index f96eb49c0..38fdad48e 100644
--- a/install_vulkan_sdk_macos.sh
+++ b/install_vulkan_sdk_macos.sh
@@ -1,19 +1,45 @@
+
 #!/usr/bin/env sh
 
 set -euo pipefail
 IFS=$'\n\t'
+new_ver_full=''
+
+# Check currently installed and latest available Vulkan SDK versions.
+if command -v jq 2>&1 >/dev/null; then
+	curl -L "https://sdk.lunarg.com/sdk/download/latest/mac/config.json" -o /tmp/vulkan-sdk.json
+
+	new_ver_full=`jq -r '.version' /tmp/vulkan-sdk.json`
+	new_ver=`echo "$new_ver_full" | awk -F. '{ printf("%d%02d%04d%02d\n", $1,$2,$3,$4); }';`
+
+	rm -f /tmp/vulkan-sdk.json
+
+	for f in $HOME/VulkanSDK/*; do
+		if [ -d "$f" ]; then
+			f=`echo "${f##*/}" | awk -F. '{ printf("%d%02d%04d%02d\n", $1,$2,$3,$4); }';`
+			if [ $f -ge $new_ver ]; then
+				echo 'Latest or newer Vulkan SDK is already installed. Skipping installation.'
+				exit 0
+			fi
+		fi
+	done
+else
+	echo 'Error: Could not find 'jq' command. Is jq installed? Try running "brew install jq" or "port install jq" and rerunning this script.'
+	exit 1
+fi
 
 # Download and install the Vulkan SDK.
 curl -L "https://sdk.lunarg.com/sdk/download/latest/mac/vulkan-sdk.zip" -o /tmp/vulkan-sdk.zip
-unzip -l /tmp/vulkan-sdk.zip | grep 'InstallVulkan.*\.app' | head -n 1 | awk '{print $4}' | tr -d '/' > /tmp/install_app_name
-
 unzip /tmp/vulkan-sdk.zip -d /tmp
-install_app_name=$(cat /tmp/install_app_name)
-/tmp/$install_app_name/Contents/MacOS/${install_app_name%\.app} \
-    --accept-licenses --default-answer --confirm-command install
 
-rm -rf /tmp/$install_app_name
+if [ -d "/tmp/vulkansdk-macOS-$new_ver_full.app" ]; then
+	/tmp/vulkansdk-macOS-$new_ver_full.app/Contents/MacOS/vulkansdk-macOS-$new_ver_full --accept-licenses --default-answer --confirm-command install
+	rm -rf /tmp/vulkansdk-macOS-$new_ver_full.app
+else
+	echo "Couldn't install the Vulkan SDK, the unzipped contents may no longer match what this script expects."
+	exit 1
+fi
+
 rm -f /tmp/vulkan-sdk.zip
-rm -f /tmp/install_app_name
 
-echo 'Vulkan SDK installed successfully! You can now build Godot by running "scons".'
\ No newline at end of file
+echo 'Vulkan SDK installed successfully! You can now build Godot by running "scons".'
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/generation/rule/ApiRule.kt b/kt/api-generator/src/main/kotlin/godot/codegen/generation/rule/ApiRule.kt
index e4ea7854f..f8a9fd69e 100644
--- a/kt/api-generator/src/main/kotlin/godot/codegen/generation/rule/ApiRule.kt
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/generation/rule/ApiRule.kt
@@ -14,6 +14,7 @@ import godot.codegen.generation.task.EnrichedClassTask
 import godot.codegen.generation.task.FileTask
 import godot.codegen.models.traits.GenerationType
 import godot.codegen.models.ApiType
+import godot.codegen.models.EnumValue
 import godot.codegen.models.enriched.EnrichedClass
 import godot.codegen.models.enriched.EnrichedMethod
 import godot.codegen.models.enriched.EnrichedNativeStructure
@@ -25,6 +26,42 @@ import godot.tools.common.constants.GodotKotlinJvmTypes
 import godot.tools.common.constants.GodotTypes
 import godot.tools.common.constants.TO_GODOT_NAME_UTIL_FUNCTION
 
+class UseConnectFlagRule : GodotApiRule<ApiTask>() {
+    override fun apply(task: ApiTask, context: GenerationContext) {
+        val objectClassIndex = context.api.classes.indexOfFirst { it.name == GodotKotlinJvmTypes.obj }
+        val objectRawClass = context.api.classes[objectClassIndex]
+
+        val connectEnumIndex = objectRawClass.enums!!.indexOfFirst { it.name == "ConnectFlags" }
+        val connectRawEnum = objectRawClass.enums[connectEnumIndex]
+
+        val newValues = listOf(
+            EnumValue(
+                "DEFAULT",
+                0,
+                "Default connections that are immediately emitted"
+            )
+        ) + connectRawEnum.values
+        val newEnum = connectRawEnum.copy(values = newValues)
+
+        val enumList = objectRawClass.enums.toMutableList()
+        enumList[connectEnumIndex] = newEnum
+
+        val connectMethodIndex = objectRawClass.methods!!.indexOfFirst { it.name == "connect" }
+        val connectMethod = objectRawClass.methods[connectMethodIndex]
+
+        val flagArgumentIndex = connectMethod.arguments!!.indexOfFirst { it.name == "flags" }
+        val flagArgument = connectMethod.arguments[flagArgumentIndex]
+
+        val newArgument = flagArgument.copy(type="enum::Object.ConnectFlags", meta = null)
+        val newMethod = connectMethod.copy(arguments = connectMethod.arguments.dropLast(1) + newArgument)
+        val newMethodList = objectRawClass.methods.toMutableList()
+        newMethodList[connectMethodIndex] = newMethod
+
+        val newClass = objectRawClass.copy(enums = enumList, methods = newMethodList)
+        context.api.classes[objectClassIndex] = newClass
+    }
+}
+
 class EnrichedCoreRule : GodotApiRule<ApiTask>() {
     override fun apply(task: ApiTask, context: GenerationContext) {
         val coreTypes = context.api.builtinClasses.associate { it.name to (it.enums?.toEnriched(GenerationType(it.name)) ?: listOf()) }
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/generationEntry.kt b/kt/api-generator/src/main/kotlin/godot/codegen/generationEntry.kt
index d27c73f79..613991534 100644
--- a/kt/api-generator/src/main/kotlin/godot/codegen/generationEntry.kt
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/generationEntry.kt
@@ -6,21 +6,19 @@ import godot.codegen.models.ApiDescription
 import godot.codegen.services.IApiGenerationService
 import godot.codegen.services.impl.ApiGenerationService
 import godot.codegen.services.impl.AwaitGenerationService
-import godot.codegen.services.impl.LambdaCallableGenerationService
+import godot.codegen.services.impl.ConnectorGenerationService
+import godot.codegen.services.impl.CallableGenerationService
 import godot.codegen.services.impl.SignalGenerationService
 import java.io.File
 
-fun generateApiFrom(jsonSource: File, coreDir: File, apiDir: File) {
+fun generateApiFrom(jsonSource: File, coreDir: File, apiDir: File, extensionDir: File) {
     val apiDescription = ObjectMapper().readValue(jsonSource, object : TypeReference<ApiDescription>() {})
     val generationService: IApiGenerationService = ApiGenerationService(apiDescription)
     generationService.generateApi(coreDir, apiDir)
 
-    LambdaCallableGenerationService.generate(coreDir)
-    SignalGenerationService.generateCore(coreDir)
-}
-
-fun generateExtension(outputDir: File) {
-    SignalGenerationService.generateExtension(outputDir)
+    SignalGenerationService.generate(coreDir)
+    CallableGenerationService.generate(coreDir)
+    ConnectorGenerationService.generate(extensionDir)
 }
 
 fun generateCoroutine(outputDir: File) {
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/models/ApiDescription.kt b/kt/api-generator/src/main/kotlin/godot/codegen/models/ApiDescription.kt
index 6353d3f6c..95110d92b 100644
--- a/kt/api-generator/src/main/kotlin/godot/codegen/models/ApiDescription.kt
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/models/ApiDescription.kt
@@ -4,14 +4,14 @@ import com.fasterxml.jackson.annotation.JsonCreator
 import com.fasterxml.jackson.annotation.JsonProperty
 
 data class ApiDescription @JsonCreator constructor(
-    @JsonProperty("header") val header: Header,
-    @JsonProperty("builtin_class_sizes") val builtinClassSizes: List<BuiltinClassSizes>,
-    @JsonProperty("builtin_class_member_offsets") val builtinClassMemberOffsets: List<BuiltinClassMemberOffsets>,
-    @JsonProperty("global_constants") val globalConstants: List<Constant>,
-    @JsonProperty("global_enums") val globalEnums: List<Enum>,
-    @JsonProperty("utility_functions") val utilityFunctions: List<UtilityFunction>,
-    @JsonProperty("builtin_classes") val builtinClasses: List<BuiltinClass>,
-    @JsonProperty("classes") val classes: List<Class>,
-    @JsonProperty("singletons") val singletons: List<Singleton>,
-    @JsonProperty("native_structures") val nativeStructures: List<NativeStructure>
+    @JsonProperty("header") var header: Header,
+    @JsonProperty("builtin_class_sizes") var builtinClassSizes: MutableList<BuiltinClassSizes>,
+    @JsonProperty("builtin_class_member_offsets") var builtinClassMemberOffsets: MutableList<BuiltinClassMemberOffsets>,
+    @JsonProperty("global_constants") var globalConstants: MutableList<Constant>,
+    @JsonProperty("global_enums") var globalEnums: MutableList<Enum>,
+    @JsonProperty("utility_functions") var utilityFunctions: MutableList<UtilityFunction>,
+    @JsonProperty("builtin_classes") val builtinClasses: MutableList<BuiltinClass>,
+    @JsonProperty("classes") var classes: MutableList<Class>,
+    @JsonProperty("singletons") var singletons: MutableList<Singleton>,
+    @JsonProperty("native_structures") var nativeStructures: MutableList<NativeStructure>
 )
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/models/traits/GenerationType.kt b/kt/api-generator/src/main/kotlin/godot/codegen/models/traits/GenerationType.kt
index 1ca0868b0..c0b3fdbc0 100644
--- a/kt/api-generator/src/main/kotlin/godot/codegen/models/traits/GenerationType.kt
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/models/traits/GenerationType.kt
@@ -10,7 +10,7 @@ import com.squareup.kotlinpoet.STRING
 import com.squareup.kotlinpoet.TypeName
 import com.squareup.kotlinpoet.UNIT
 import godot.tools.common.constants.GODOT_ARRAY
-import godot.tools.common.constants.GODOT_CALLABLE_BASE
+import godot.tools.common.constants.GODOT_CALLABLE
 import godot.tools.common.constants.GODOT_DICTIONARY
 import godot.tools.common.constants.GodotTypes
 import godot.tools.common.constants.VARIANT_CASTER_ANY
@@ -113,7 +113,7 @@ fun ClassName.Companion.from(type: TypeGenerationTrait) = when {
     type.identifier == GodotTypes.float -> DOUBLE
     type.identifier == GodotTypes.string -> STRING
     type.identifier == GodotTypes.variant -> ANY
-    type.identifier == GodotTypes.callable -> GODOT_CALLABLE_BASE
+    type.identifier == GodotTypes.callable -> GODOT_CALLABLE
     type.identifier == GodotTypes.array || type.isTypedArray() -> GODOT_ARRAY
     type.identifier == GodotTypes.dictionary -> GODOT_DICTIONARY
     type.isCoreType() -> ClassName(godotCorePackage, type.identifier)
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/poet/GenericClassNameInfo.kt b/kt/api-generator/src/main/kotlin/godot/codegen/poet/GenericClassNameInfo.kt
index cae8f7d05..df779e6ff 100644
--- a/kt/api-generator/src/main/kotlin/godot/codegen/poet/GenericClassNameInfo.kt
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/poet/GenericClassNameInfo.kt
@@ -7,17 +7,43 @@ import com.squareup.kotlinpoet.KModifier
 import com.squareup.kotlinpoet.LambdaTypeName
 import com.squareup.kotlinpoet.ParameterSpec
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.TypeName
 import com.squareup.kotlinpoet.TypeSpec
 import com.squareup.kotlinpoet.TypeVariableName
 
-// Helper that provide utilities to handle generic classes.
+/**
+ * Provides utilities to handle generic classes and generate KotlinPoet builders for them.
+ *
+ * @property className The base [ClassName] representing the class.
+ * @param numberOfGenericParameters The number of generic type parameters for the class.
+ */
 class GenericClassNameInfo(
     val className: ClassName,
     numberOfGenericParameters: Int
 ) {
+    /**
+     * Return list of generic argument type names.
+     *
+     * Example: genericTypes = [P0, P1]
+     */
     val genericTypes = Array(numberOfGenericParameters) {
         TypeVariableName("P$it")
     }.toList()
+
+
+    /**
+     * List of reified type variables for inline functions.
+     *
+     * Example: [reified P0, reified P1]
+     */
+    val reifiedTypes = genericTypes.map { it.copy(reified = true) }
+
+
+    /**
+     * Parameterized [ClassName] with generic type variables.
+     *
+     * Example: MyClass<P0, P1>
+     */
     val genericClassName = className.run {
         if (genericTypes.isNotEmpty()) {
             parameterizedBy(genericTypes)
@@ -26,7 +52,11 @@ class GenericClassNameInfo(
         }
     }
 
-    val reifiedTypes = genericTypes.map { it.copy(reified = true) }
+    /**
+     * Parameterized [ClassName] with reified generic type variables.
+     *
+     * Example: MyClass<reified P0, reified P1>
+     */
     val reifiedClassName = className.run {
         if (reifiedTypes.isNotEmpty()) {
             parameterizedBy(reifiedTypes)
@@ -35,6 +65,11 @@ class GenericClassNameInfo(
         }
     }
 
+    /**
+     * Parameterized [ClassName] with generic parameters erased to [ANY].
+     *
+     * Example: MyClass<Any, Any>
+     */
     val erasedGenericClassName = className.run {
         if (genericTypes.isNotEmpty()) {
             parameterizedBy(genericTypes.map { ANY })
@@ -43,34 +78,130 @@ class GenericClassNameInfo(
         }
     }
 
-    fun toTypeSpecBuilder() = TypeSpec
-        .classBuilder(className)
-        .addTypeVariables(genericTypes)
+    /**
+     * Combine optional [prefix], core [genericTypes], and optional [suffix] into one list.
+     */
+    private fun allTypeVariables(
+        prefix: List<TypeVariableName> = emptyList(),
+        suffix: List<TypeVariableName> = emptyList()
+    ) = prefix + genericTypes + suffix
+
+    /**
+     * Builds a [TypeSpec.Builder] for the class with type variables.
+     *
+     * Example: toTypeSpecBuilder(prefix, suffix) -> TypeSpec.classBuilder("MyClass").addTypeVariables(prefix + [P0,P1] + suffix)
+     */
+    fun toTypeSpecBuilder(
+        prefix: List<TypeVariableName> = emptyList(),
+        suffix: List<TypeVariableName> = emptyList()
+    ) = TypeSpec.classBuilder(className.simpleName)
+        .addTypeVariables(allTypeVariables(prefix, suffix))
+
+    /**
+     * Builds a [FunSpec.Builder] with generic type variables.
+     *
+     * Example: builder("foo", prefix, suffix) -> builder("foo").addTypeVariables(prefix + [P0,P1] + suffix)
+     */
+    fun toFunSpecBuilder(
+        name: String,
+        prefix: List<TypeVariableName> = emptyList(),
+        suffix: List<TypeVariableName> = emptyList()
+    ) = FunSpec.builder(name)
+        .addTypeVariables(allTypeVariables(prefix, suffix))
 
-    fun toFunSpecBuilder(name: String) = FunSpec
-        .builder(name)
-        .addTypeVariables(genericTypes)
 
-    fun toExtensionFunSpecBuilder(name: String) = toFunSpecBuilder(name).receiver(genericClassName)
+    /**
+     * Builds an extension [FunSpec.Builder] on [genericClassName].
+     *
+     * Example: fun <X,P0,P1,Y> MyClass<P0,P1>.foo() {...}
+     */
+    fun toExtensionFunSpecBuilder(
+        name: String,
+        prefix: List<TypeVariableName> = emptyList(),
+        suffix: List<TypeVariableName> = emptyList()
+    ) = toFunSpecBuilder(name, prefix, suffix)
+        .receiver(genericClassName)
 
-    fun toReifiedFunSpecBuilder(name: String) = FunSpec
-        .builder(name)
-        .addTypeVariables(reifiedTypes)
+
+    /**
+     * Begin building a reified inline FunSpec with reified type parameters.
+     *
+     * Example: inline fun <X, reified P0, reified P1, Y> foo() {...}
+     */
+    fun toReifiedFunSpecBuilder(
+        name: String,
+        prefix: List<TypeVariableName> = emptyList(),
+        suffix: List<TypeVariableName> = emptyList()
+    ) = FunSpec.builder(name)
         .addModifiers(KModifier.INLINE)
+        .addTypeVariables(prefix + reifiedTypes + suffix)
+
 
-    fun toReifiedExtensionFunSpecBuilder(name: String) = toReifiedFunSpecBuilder(name).receiver(reifiedClassName)
+    /**
+     * Begin building a reified inline extension FunSpec on the class.
+     *
+     * Example: inline fun <reified P0, reified P1> MyClass<P0, P1>.foo() {...}
+     */
+    fun toReifiedExtensionFunSpecBuilder(
+        name: String,
+        prefix: List<TypeVariableName> = emptyList(),
+        suffix: List<TypeVariableName> = emptyList()
+    ) = toReifiedFunSpecBuilder(name, prefix, suffix)
+        .receiver(reifiedClassName)
 
+
+    /**
+     * Generate a list of parameters matching the generic type variables.
+     *
+     * Example: [ParameterSpec("p0", P0), ParameterSpec("p1", P1)]
+     */
     fun toParameterSpecList() = genericTypes
         .mapIndexed { index: Int, typeVariableName: TypeVariableName ->
             ParameterSpec.builder("p$index", typeVariableName).build()
         }
 
-    fun toLambdaTypeName(returnType: TypeVariableName) = LambdaTypeName.get(
-        receiver = null,
+    /**
+     * Build a comma-separated argument string based on a template.
+     *
+     * @param template String template where occurrences of `{$indexKey}` will be replaced by index
+     * @param indexKey placeholder key in template (e.g., "%d")
+     *
+     * Example: toArgumentsString("p%{i}", "{i}") -> "p0, p1"
+     */
+    fun toArgumentsString(template: String, indexKey: String): String {
+        return buildString {
+            genericTypes.mapIndexed { index: Int, typeVariableName: TypeVariableName ->
+                if (index != 0) append(",·")
+                append(template.replace(indexKey, index.toString()))
+            }
+        }
+    }
+
+    /**
+     * Create a LambdaTypeName taking generic types as parameters and returning [returnType].
+     *
+     * Example: toLambdaTypeName(R) -> (p0: P0, p1: P1) -> R
+     */
+    fun toLambdaTypeName(returnType: TypeName, receiver: TypeName? = null) = LambdaTypeName.get(
+        receiver = receiver,
         parameters = genericTypes
             .mapIndexed { index: Int, typeVariableName: TypeVariableName ->
                 ParameterSpec.builder("p$index", typeVariableName).build()
             },
         returnType = returnType
     )
+
+    /**
+     * Create a LambdaTypeName that use all parameters as Any? and returning [returnType].
+     *
+     * Example: toErasedLambdaTypeName(R) -> (p0: Any?, p1: Any?) -> R
+     */
+    fun toErasedLambdaTypeName(returnType: TypeName, receiver: TypeName? = null) = LambdaTypeName.get(
+        receiver = receiver,
+        parameters = genericTypes
+            .mapIndexed { index: Int, typeVariableName: TypeVariableName ->
+                ParameterSpec.builder("p$index", ANY.copy(nullable = true)).build()
+            },
+        returnType = returnType
+    )
 }
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/ILambdaCallableGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/ICallableGenerationService.kt
similarity index 66%
rename from kt/api-generator/src/main/kotlin/godot/codegen/services/ILambdaCallableGenerationService.kt
rename to kt/api-generator/src/main/kotlin/godot/codegen/services/ICallableGenerationService.kt
index 38e433b40..b53d9d3ce 100644
--- a/kt/api-generator/src/main/kotlin/godot/codegen/services/ILambdaCallableGenerationService.kt
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/ICallableGenerationService.kt
@@ -2,6 +2,6 @@ package godot.codegen.services
 
 import java.io.File
 
-interface ILambdaCallableGenerationService {
+interface ICallableGenerationService {
     fun generate(outputDir: File)
 }
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/IConnectorGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/IConnectorGenerationService.kt
new file mode 100644
index 000000000..2f8407b3f
--- /dev/null
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/IConnectorGenerationService.kt
@@ -0,0 +1,7 @@
+package godot.codegen.services
+
+import java.io.File
+
+interface IConnectorGenerationService {
+    fun generate(extensionDir: File)
+}
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/ISignalGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/ISignalGenerationService.kt
index de2abba47..7b4471bf8 100644
--- a/kt/api-generator/src/main/kotlin/godot/codegen/services/ISignalGenerationService.kt
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/ISignalGenerationService.kt
@@ -3,6 +3,5 @@ package godot.codegen.services
 import java.io.File
 
 interface ISignalGenerationService {
-    fun generateCore(outputDir: File)
-    fun generateExtension(outputDir: File)
+    fun generate(outputDir: File)
 }
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/ApiGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/ApiGenerationService.kt
index 4bb0ccf96..bb0417b02 100644
--- a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/ApiGenerationService.kt
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/ApiGenerationService.kt
@@ -6,7 +6,6 @@ import godot.codegen.generation.rule.BindingRule
 import godot.codegen.generation.rule.BitfieldExtensionRule
 import godot.codegen.generation.rule.ConstantRule
 import godot.codegen.generation.rule.CoreRule
-import godot.codegen.generation.rule.LocalCopyHelperRule
 import godot.codegen.generation.rule.DocumentationRule
 import godot.codegen.generation.rule.EnrichedClassRule
 import godot.codegen.generation.rule.EnrichedCoreRule
@@ -14,6 +13,7 @@ import godot.codegen.generation.rule.EnumRule
 import godot.codegen.generation.rule.FileRule
 import godot.codegen.generation.rule.HeaderCommentRule
 import godot.codegen.generation.rule.ImportRule
+import godot.codegen.generation.rule.LocalCopyHelperRule
 import godot.codegen.generation.rule.MemberRule
 import godot.codegen.generation.rule.MethodRule
 import godot.codegen.generation.rule.ObjectRule
@@ -23,6 +23,7 @@ import godot.codegen.generation.rule.RegistrationRule
 import godot.codegen.generation.rule.SignalRule
 import godot.codegen.generation.rule.StaticRule
 import godot.codegen.generation.rule.StringOnlyRule
+import godot.codegen.generation.rule.UseConnectFlagRule
 import godot.codegen.generation.rule.WarningRule
 import godot.codegen.generation.rule.compile
 import godot.codegen.generation.task.ApiTask
@@ -43,6 +44,7 @@ class ApiGenerationService(
         val context = GenerationContext(api)
 
         ApiTask(coreDir, apiDir).compile(context) {
+            rule(::UseConnectFlagRule)
             rule(::EnrichedCoreRule)
             rule(::EnrichedClassRule)
             rule(::CoreRule)
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/AwaitGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/AwaitGenerationService.kt
index d2c19336d..542a5708c 100644
--- a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/AwaitGenerationService.kt
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/AwaitGenerationService.kt
@@ -14,8 +14,6 @@ import com.squareup.kotlinpoet.TypeVariableName
 import com.squareup.kotlinpoet.UNIT
 import godot.codegen.services.IAwaitGenerationService
 import godot.common.constants.Constraints
-import godot.tools.common.constants.AS_CALLABLE_UTIL_FUNCTION
-import godot.tools.common.constants.GODOT_OBJECT
 import godot.tools.common.constants.GodotKotlinJvmTypes.signal
 import godot.tools.common.constants.godotCorePackage
 import godot.tools.common.constants.godotCoroutinePackage
@@ -26,7 +24,7 @@ import java.io.File
 
 private val cancellableContinuationClass = ClassName(kotlinxCoroutinePackage, "CancellableContinuation")
 private val suspendCancellableCoroutine = MemberName(kotlinxCoroutinePackage, "suspendCancellableCoroutine")
-private val connectThreadSafe = MemberName(godotExtensionPackage, "connectThreadSafe")
+private val promise = MemberName(godotExtensionPackage, "promise")
 private val resume = MemberName(kotlinCoroutinePackage, "resume")
 private const val cancel = "cancel"
 
@@ -138,14 +136,10 @@ object AwaitGenerationService : IAwaitGenerationService {
         return this
             .beginControlFlow("return·%M", suspendCancellableCoroutine)
             .addStatement("cont:·%T<%T>·->", cancellableContinuationClass, returnType)
-            .beginControlFlow("%M(", connectThreadSafe)
-            .addStatement("$lambdaParametersWithType·->")
-            .addStatement("cont.%M($resumeParameters)", resume)
-            .endControlFlow()
-            .beginControlFlow(".%M", AS_CALLABLE_UTIL_FUNCTION)
-            .addStatement("cont.%L()", cancel)
-            .endControlFlow()
-            .addCode(",·%T.ConnectFlags.ONE_SHOT.id.toInt())", GODOT_OBJECT)
+            .addStatement("%M(", promise)
+            .addStatement("{·$lambdaParametersWithType·->·cont.%M($resumeParameters)·},", resume)
+            .addStatement("{·cont.%L()·},", cancel)
+            .addStatement(")")
             .endControlFlow()
     }
 }
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt
new file mode 100644
index 000000000..8fe0b4068
--- /dev/null
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt
@@ -0,0 +1,480 @@
+package godot.codegen.services.impl
+
+import com.squareup.kotlinpoet.ANY
+import com.squareup.kotlinpoet.ARRAY
+import com.squareup.kotlinpoet.AnnotationSpec
+import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.CodeBlock
+import com.squareup.kotlinpoet.FileSpec
+import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.MemberName
+import com.squareup.kotlinpoet.ParameterSpec
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.TypeSpec
+import com.squareup.kotlinpoet.TypeVariableName
+import com.squareup.kotlinpoet.asClassName
+import godot.codegen.poet.GenericClassNameInfo
+import godot.codegen.services.ICallableGenerationService
+import godot.common.constants.Constraints
+import godot.tools.common.constants.GODOT_METHOD_CALLABLE
+import godot.tools.common.constants.GODOT_OBJECT
+import godot.tools.common.constants.GodotFunctions
+import godot.tools.common.constants.GodotKotlinJvmTypes
+import godot.tools.common.constants.STRING_NAME
+import godot.tools.common.constants.TO_GODOT_NAME_UTIL_FUNCTION
+import godot.tools.common.constants.VARIANT_PARSER_NIL
+import godot.tools.common.constants.godotCorePackage
+import godot.tools.common.constants.godotInteropPackage
+import java.io.File
+import kotlin.reflect.KCallable
+
+
+object CallableGenerationService : ICallableGenerationService {
+    private const val CALLABLE_NAME = "Callable"
+    private const val LAMBDA_CALLABLE_NAME = "LambdaCallable"
+    private const val LAMBDA_CONTAINER_NAME = "LambdaContainer"
+    private const val METHOD_CALLABLE_NAME = "MethodCallable"
+
+    private const val FUNCTION_PARAMETER_NAME = "function"
+    private const val CONTAINER_ARGUMENT_NAME = "container"
+    private const val TARGET_ARGUMENT_NAME = "target"
+    private const val METHOD_NAME_ARGUMENT_NAME = "methodName"
+    private const val BOUND_ARGS_ARGUMENT_NAME = "boundArgs"
+    private const val CALLABLE_FUNCTION_NAME = "callable"
+    private const val VARIANT_TYPE_RETURN_NAME = "returnConverter"
+    private const val VARIANT_TYPE_ARGUMENT_NAME = "typeConverters"
+
+    private val CALLABLE_CLASS_NAME = ClassName(godotCorePackage, CALLABLE_NAME)
+    private val LAMBDA_CALLABLE_CLASS_NAME = ClassName(godotCorePackage, LAMBDA_CALLABLE_NAME)
+    private val LAMBDA_CONTAINER_CLASS_NAME = ClassName(godotCorePackage, LAMBDA_CONTAINER_NAME)
+    private val METHOD_CALLABLE_CLASS_NAME = ClassName(godotCorePackage, METHOD_CALLABLE_NAME)
+
+    private val returnTypeParameter = TypeVariableName("R", ANY.copy(nullable = true))
+    private val variantConverterClassName = ClassName(godotInteropPackage, GodotKotlinJvmTypes.variantConverter)
+
+    override fun generate(outputDir: File) {
+        val callableFileSpec = FileSpec.builder(godotCorePackage, CALLABLE_NAME + "s")
+        val lambdaFileSpec = FileSpec.builder(godotCorePackage, LAMBDA_CALLABLE_NAME + "s")
+        val containerFileSpec = FileSpec.builder(godotCorePackage, LAMBDA_CONTAINER_NAME + "s")
+        val methodFileSpec = FileSpec.builder(godotCorePackage, METHOD_CALLABLE_NAME + "s")
+
+        for (argCount in 0..Constraints.MAX_FUNCTION_ARG_COUNT) {
+
+            val callableClassName = ClassName(godotCorePackage, "$CALLABLE_NAME$argCount")
+            val lambdaContainerClassName = ClassName(godotCorePackage, "$LAMBDA_CONTAINER_NAME$argCount")
+            val lambdaCallableClassName = ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME$argCount")
+            val methodCallableClassName = ClassName(godotCorePackage, "$METHOD_CALLABLE_NAME$argCount")
+
+            val callableInfo = GenericClassNameInfo(callableClassName, argCount)
+            val containerInfo = GenericClassNameInfo(lambdaContainerClassName, argCount)
+            val lambdaInfo = GenericClassNameInfo(lambdaCallableClassName, argCount)
+            val methodCallableInfo = GenericClassNameInfo(methodCallableClassName, argCount)
+
+            val genericParameters = containerInfo.genericTypes
+            val lambdaTypeName = lambdaInfo.toLambdaTypeName(returnType = returnTypeParameter)
+
+            val callableClassBuilder = TypeSpec
+                .interfaceBuilder(callableClassName)
+                .addSuperinterface(CALLABLE_CLASS_NAME)
+                .addTypeVariable(returnTypeParameter)
+                .addTypeVariables(genericParameters)
+                .addFunction(
+                    FunSpec
+                        .builder("call")
+                        .addParameters(callableInfo.toParameterSpecList())
+                        .returns(returnTypeParameter)
+                        .addCode(
+                            CodeBlock.of(
+                                buildString {
+                                    append("return·callUnsafe(")
+                                    append(callableInfo.toArgumentsString("pINDEX", "INDEX"))
+                                    append(") as R")
+                                }
+                            )
+                        )
+                        .build()
+                )
+                .addFunction(
+                    FunSpec.builder("callDeferred")
+                        .addParameters(callableInfo.toParameterSpecList())
+                        .addCode(
+                            CodeBlock.of(
+                                buildString {
+                                    append("return·callDeferredUnsafe(")
+                                    append(callableInfo.toArgumentsString("pINDEX", "INDEX"))
+                                    append(")")
+                                }
+                            )
+                        )
+                        .build()
+                )
+                .addFunction(
+                    FunSpec.builder("invoke")
+                        .addParameters(lambdaInfo.toParameterSpecList())
+                        .returns(returnTypeParameter)
+                        .addCode(
+                            CodeBlock.of(
+                                buildString {
+                                    append("return·call(")
+                                    append(callableInfo.toArgumentsString("pINDEX", "INDEX"))
+                                    append(')')
+                                },
+                                *genericParameters.toTypedArray()
+                            )
+                        )
+                        .addModifiers(KModifier.OPERATOR)
+                        .build()
+                )
+
+            val lambdaContainerClassBuilder = TypeSpec
+                .classBuilder(lambdaContainerClassName)
+                .superclass(LAMBDA_CONTAINER_CLASS_NAME.parameterizedBy(returnTypeParameter))
+                .addSuperclassConstructorParameter(VARIANT_TYPE_RETURN_NAME)
+                .addSuperclassConstructorParameter(VARIANT_TYPE_ARGUMENT_NAME)
+                .addSuperclassConstructorParameter(FUNCTION_PARAMETER_NAME)
+                .addTypeVariable(returnTypeParameter)
+                .addTypeVariables(genericParameters)
+                .primaryConstructor(
+                    FunSpec
+                        .constructorBuilder()
+                        .addParameter(
+                            ParameterSpec
+                                .builder(
+                                    VARIANT_TYPE_RETURN_NAME,
+                                    variantConverterClassName
+                                )
+                                .build()
+                        )
+                        .addParameter(
+                            ParameterSpec
+                                .builder(
+                                    VARIANT_TYPE_ARGUMENT_NAME,
+                                    ARRAY.parameterizedBy(variantConverterClassName)
+                                )
+                                .build()
+                        )
+                        .addParameter(
+                            ParameterSpec
+                                .builder(
+                                    FUNCTION_PARAMETER_NAME,
+                                    lambdaTypeName
+                                )
+                                .build()
+                        )
+                        .build()
+                )
+                .addFunction(
+                    FunSpec
+                        .builder("invokeUnsafe")
+                        .addModifiers(KModifier.OVERRIDE)
+                        .addParameter(
+                            ParameterSpec
+                                .builder("args", ANY.copy(nullable = true), KModifier.VARARG)
+                                .build()
+                        )
+                        .returns(returnTypeParameter)
+                        .addCode(
+                            CodeBlock.of(
+                                buildString {
+                                    append("return·($FUNCTION_PARAMETER_NAME·as?·%T)?.invoke(")
+                                    append(lambdaInfo.toArgumentsString("args[INDEX]", "INDEX"))
+                                    append(")?:·throw·%T()")
+                                },
+                                lambdaInfo.toErasedLambdaTypeName(returnType = returnTypeParameter),
+                                ClassName(godotCorePackage, "InvalidJvmLambdaException")
+                            )
+                        )
+                        .build()
+
+                )
+
+            val lambdaCallableClassBuilder = TypeSpec
+                .classBuilder(lambdaCallableClassName)
+                .superclass(LAMBDA_CALLABLE_CLASS_NAME.parameterizedBy(returnTypeParameter))
+                .addSuperinterface(callableClassName.parameterizedBy(listOf(returnTypeParameter) + genericParameters))
+                .addTypeVariable(returnTypeParameter)
+                .addTypeVariables(genericParameters)
+                .primaryConstructor(
+                    FunSpec
+                        .constructorBuilder()
+                        .addModifiers(KModifier.INTERNAL)
+                        .addParameter(
+                            ParameterSpec
+                                .builder(
+                                    CONTAINER_ARGUMENT_NAME,
+                                    LAMBDA_CONTAINER_CLASS_NAME.parameterizedBy(returnTypeParameter)
+                                )
+                                .build()
+                        )
+                        .addParameter(
+                            ParameterSpec
+                                .builder(
+                                    BOUND_ARGS_ARGUMENT_NAME,
+                                    ARRAY.parameterizedBy(ANY.copy(nullable = true))
+                                )
+                                .defaultValue("emptyArray()")
+                                .build()
+                        )
+                        .addAnnotation(PublishedApi::class)
+                        .build()
+                )
+                .addSuperclassConstructorParameter(CONTAINER_ARGUMENT_NAME)
+                .addSuperclassConstructorParameter(BOUND_ARGS_ARGUMENT_NAME)
+
+            val methodCallableClassBuilder = TypeSpec
+                .classBuilder(methodCallableClassName)
+                .superclass(METHOD_CALLABLE_CLASS_NAME)
+                .addSuperinterface(callableClassName.parameterizedBy(listOf(returnTypeParameter) + genericParameters))
+                .addTypeVariable(returnTypeParameter)
+                .addTypeVariables(genericParameters)
+                .primaryConstructor(
+                    FunSpec
+                        .constructorBuilder()
+                        .addModifiers(KModifier.INTERNAL)
+                        .addParameter(
+                            ParameterSpec
+                                .builder(
+                                    TARGET_ARGUMENT_NAME,
+                                    GODOT_OBJECT
+                                )
+                                .build()
+                        )
+                        .addParameter(
+                            ParameterSpec
+                                .builder(
+                                    METHOD_NAME_ARGUMENT_NAME,
+                                    STRING_NAME
+                                )
+                                .build()
+                        )
+                        .addParameter(
+                            ParameterSpec
+                                .builder(
+                                    BOUND_ARGS_ARGUMENT_NAME,
+                                    ARRAY.parameterizedBy(ANY.copy(nullable = true))
+                                )
+                                .defaultValue("emptyArray()")
+                                .build()
+                        )
+                        .addAnnotation(PublishedApi::class)
+                        .build()
+                )
+                .addSuperclassConstructorParameter(TARGET_ARGUMENT_NAME)
+                .addSuperclassConstructorParameter(METHOD_NAME_ARGUMENT_NAME)
+                .addSuperclassConstructorParameter(BOUND_ARGS_ARGUMENT_NAME)
+
+            val typeVariables = genericParameters.toMutableList()
+            var remainingParameters = 0
+            while (typeVariables.isNotEmpty()) {
+                val boundCallableClassName = ClassName(godotCorePackage, "$CALLABLE_NAME${remainingParameters}")
+                val boundLambdaCallableClassName = ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME${remainingParameters}")
+                val boundMethodCallableClassName = ClassName(godotCorePackage, "$METHOD_CALLABLE_NAME${remainingParameters}")
+
+                val bindInfo = GenericClassNameInfo(boundLambdaCallableClassName, remainingParameters)
+
+                callableClassBuilder.addFunction(
+                    FunSpec.builder("bind")
+                        .addModifiers(KModifier.ABSTRACT)
+                        .addParameters(
+                            typeVariables.mapIndexed { index: Int, typeVariableName: TypeVariableName ->
+                                ParameterSpec.builder("p${index + remainingParameters}", typeVariableName)
+                                    .build()
+                            }
+                        )
+                        .returns(boundCallableClassName.parameterizedBy(listOf(returnTypeParameter) + bindInfo.genericTypes))
+                        .build()
+                )
+
+                lambdaCallableClassBuilder.addFunction(
+                    FunSpec.builder("bind")
+                        .addModifiers(KModifier.OVERRIDE)
+                        .addParameters(
+                            typeVariables.mapIndexed { index: Int, typeVariableName: TypeVariableName ->
+                                ParameterSpec.builder("p${index + remainingParameters}", typeVariableName)
+                                    .build()
+                            }
+                        )
+                        .addCode(
+                            buildString {
+                                append("return·%T($CONTAINER_ARGUMENT_NAME, arrayOf<Any?>(")
+
+                                for (index in (0..<typeVariables.size)) {
+                                    if (index != 0) append(",·")
+                                    append("p${index + remainingParameters}")
+                                }
+
+                                append(", *$BOUND_ARGS_ARGUMENT_NAME))")
+                            },
+                            boundLambdaCallableClassName.parameterizedBy(listOf(returnTypeParameter) + bindInfo.genericTypes),
+                        )
+                        .build()
+                )
+
+                methodCallableClassBuilder.addFunction(
+                    FunSpec.builder("bind")
+                        .addModifiers(KModifier.OVERRIDE)
+                        .addParameters(
+                            typeVariables.mapIndexed { index: Int, typeVariableName: TypeVariableName ->
+                                ParameterSpec.builder("p${index + remainingParameters}", typeVariableName)
+                                    .build()
+                            }
+                        )
+                        .addCode(
+                            buildString {
+                                append("return·%T($TARGET_ARGUMENT_NAME, $METHOD_NAME_ARGUMENT_NAME, arrayOf<Any?>(")
+
+                                for (index in (0..<typeVariables.size)) {
+                                    if (index != 0) append(",·")
+                                    append("p${index + remainingParameters}")
+                                }
+
+                                append(", *$BOUND_ARGS_ARGUMENT_NAME))")
+                            },
+                            boundMethodCallableClassName.parameterizedBy(listOf(returnTypeParameter) + bindInfo.genericTypes),
+                        )
+                        .build()
+                )
+
+                typeVariables.removeFirst()
+                ++remainingParameters
+            }
+
+            callableFileSpec.addType(callableClassBuilder.build())
+            containerFileSpec.addType(lambdaContainerClassBuilder.build())
+            lambdaFileSpec.addType(lambdaCallableClassBuilder.build())
+            methodFileSpec.addType(methodCallableClassBuilder.build())
+
+
+            val variantMapperMember = MemberName(godotCorePackage, "variantMapper")
+            lambdaFileSpec.addFunction(
+                FunSpec.builder(CALLABLE_FUNCTION_NAME + argCount)
+                    .addTypeVariable(returnTypeParameter.copy(reified = true))
+                    .addTypeVariables(genericParameters.map { it.copy(reified = true) })
+                    .addModifiers(KModifier.INLINE)
+                    .addParameters(
+                        listOf(
+                            ParameterSpec
+                                .builder(
+                                    FUNCTION_PARAMETER_NAME,
+                                    lambdaTypeName
+                                )
+                                .addModifiers(KModifier.NOINLINE)
+                                .build()
+                        )
+                    )
+                    .addCode(
+                        CodeBlock.of(
+                            buildString {
+                                append("return·%T(%T(")
+                                append("%M.getOrDefault(%T::class,·%T),·arrayOf(")
+                                genericParameters.forEachIndexed { index, _ ->
+                                    if (index != 0) append(",·")
+                                    append("%M[%T::class]!!")
+                                }
+                                append("),·")
+                                append(FUNCTION_PARAMETER_NAME)
+                                append("))")
+                            },
+                            lambdaInfo.className.parameterizedBy(listOf(returnTypeParameter) + genericParameters),
+                            containerInfo.className.parameterizedBy(listOf(returnTypeParameter) + genericParameters),
+                            variantMapperMember,
+                            returnTypeParameter,
+                            VARIANT_PARSER_NIL,
+                            *genericParameters
+                                .flatMap {
+                                    listOf(variantMapperMember, it)
+                                }
+                                .toTypedArray()
+                        )
+                    )
+                    .build()
+            )
+
+            lambdaFileSpec
+                .addFunction(
+                    FunSpec
+                        .builder(GodotFunctions.asCallable)
+                        .addTypeVariable(returnTypeParameter.copy(reified = true))
+                        .addTypeVariables(genericParameters.map { it.copy(reified = true) })
+                        .addModifiers(KModifier.INLINE)
+                        .receiver(lambdaTypeName)
+                        .addCode("return·$CALLABLE_FUNCTION_NAME$argCount(this)")
+                        .build()
+                )
+
+            val objectGeneric = TypeVariableName("T", GODOT_OBJECT)
+            methodFileSpec
+                .addFunction(
+                    FunSpec.builder(CALLABLE_FUNCTION_NAME + argCount)
+                        .addTypeVariable(objectGeneric)
+                        .addTypeVariable(returnTypeParameter)
+                        .addTypeVariables(genericParameters)
+                        .receiver(objectGeneric)
+                        .addParameters(
+                            listOf(
+                                ParameterSpec
+                                    .builder(
+                                        CALLABLE_FUNCTION_NAME,
+                                        methodCallableInfo.toLambdaTypeName(returnType =returnTypeParameter, receiver = objectGeneric)
+                                    )
+                                    .build()
+                            )
+                        )
+                        .addCode(
+                            CodeBlock.of(
+                                "return·%T(this,·($CALLABLE_FUNCTION_NAME·as·%T<R>).name.%M())",
+                                methodCallableClassName.parameterizedBy(listOf(returnTypeParameter) + genericParameters),
+                                KCallable::class.asClassName(),
+                                TO_GODOT_NAME_UTIL_FUNCTION,
+                            )
+                        )
+                        .build()
+                )
+        }
+
+        callableFileSpec
+            .addAnnotation(
+                AnnotationSpec
+                    .builder(ClassName("kotlin", "Suppress"))
+                    .addMember("\"PackageDirectoryMismatch\", \"UNCHECKED_CAST\"")
+                    .addMember("\"unused\"")
+                    .build()
+            )
+            .build()
+            .writeTo(outputDir)
+
+        containerFileSpec
+            .addAnnotation(
+                AnnotationSpec
+                    .builder(ClassName("kotlin", "Suppress"))
+                    .addMember("\"PackageDirectoryMismatch\", \"UNCHECKED_CAST\"")
+                    .addMember("\"unused\"")
+                    .build()
+            )
+            .build()
+            .writeTo(outputDir)
+
+        lambdaFileSpec
+            .addAnnotation(
+                AnnotationSpec
+                    .builder(ClassName("kotlin", "Suppress"))
+                    .addMember("\"PackageDirectoryMismatch\", \"UNCHECKED_CAST\"")
+                    .addMember("\"unused\"")
+                    .build()
+            )
+            .build()
+            .writeTo(outputDir)
+
+        methodFileSpec
+            .addAnnotation(
+                AnnotationSpec
+                    .builder(ClassName("kotlin", "Suppress"))
+                    .addMember("\"PackageDirectoryMismatch\", \"UNCHECKED_CAST\"")
+                    .addMember("\"unused\"")
+                    .build()
+            )
+            .build()
+            .writeTo(outputDir)
+    }
+}
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/ConnectorGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/ConnectorGenerationService.kt
new file mode 100644
index 000000000..323ac0145
--- /dev/null
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/ConnectorGenerationService.kt
@@ -0,0 +1,197 @@
+package godot.codegen.services.impl
+
+import com.squareup.kotlinpoet.AnnotationSpec
+import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.CodeBlock
+import com.squareup.kotlinpoet.FileSpec
+import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.LambdaTypeName
+import com.squareup.kotlinpoet.MemberName
+import com.squareup.kotlinpoet.ParameterSpec
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.TypeVariableName
+import com.squareup.kotlinpoet.UNIT
+import com.squareup.kotlinpoet.asClassName
+import godot.codegen.poet.GenericClassNameInfo
+import godot.codegen.services.IConnectorGenerationService
+import godot.common.constants.Constraints
+import godot.tools.common.constants.GODOT_METHOD_CALLABLE
+import godot.tools.common.constants.GODOT_SIGNAL_CONNECTOR
+import godot.tools.common.constants.GODOT_OBJECT
+import godot.tools.common.constants.GodotKotlinJvmTypes
+import godot.tools.common.constants.TO_GODOT_NAME_UTIL_FUNCTION
+import godot.tools.common.constants.godotApiPackage
+import godot.tools.common.constants.godotCorePackage
+import godot.tools.common.constants.godotExtensionPackage
+import java.io.File
+import kotlin.reflect.KCallable
+
+object ConnectorGenerationService : IConnectorGenerationService {
+    private const val LAMBDA_CONTAINER_NAME = "LambdaContainer"
+    private const val SIGNAL_CLASS_NAME = "Signal"
+    private const val CONNECT_METHOD_METHOD_NAME = "connectMethod"
+    private const val CONNECT_LAMBDA_METHOD_NAME = "connectLambda"
+    private const val PROMISE_METHOD_NAME = "promise"
+    private const val METHOD_PARAMETER_NAME = "method"
+    private const val CANCEL_PARAMETER_NAME = "cancel"
+    private const val FLAGS_PARAMETER_NAME = "flags"
+    private const val TARGET_PARAMETER_NAME = "target"
+    private val godotObjectBoundTypeVariable = TypeVariableName("T", GODOT_OBJECT)
+    private val connectFlagClassName = ClassName(godotApiPackage, "Object.ConnectFlags")
+    private val variantConverterClassName = ClassName(godotCorePackage, GodotKotlinJvmTypes.variantParser)
+    private val variantMapperMember = MemberName(godotCorePackage, "variantMapper")
+    private val asCallableMember= MemberName(godotCorePackage, "asCallable")
+
+    override fun generate(output: File) {
+        val connectorFileSpec = FileSpec.builder(godotExtensionPackage, "SignalConnectors")
+
+        for (argCount in 0..Constraints.MAX_FUNCTION_ARG_COUNT) {
+            val signalClassName = ClassName(godotCorePackage, "$SIGNAL_CLASS_NAME$argCount")
+            val genericClassNameInfo = GenericClassNameInfo(signalClassName, argCount)
+            val genericParameters = genericClassNameInfo.genericTypes
+
+            val flagsParameter = ParameterSpec.builder(FLAGS_PARAMETER_NAME, connectFlagClassName)
+                .defaultValue("%T.%L", connectFlagClassName, "DEFAULT")
+                .build()
+
+
+            connectorFileSpec.addFunction(
+                genericClassNameInfo
+                    .toReifiedExtensionFunSpecBuilder(CONNECT_LAMBDA_METHOD_NAME)
+                    .addParameters(
+                        listOf(
+                            flagsParameter,
+                            ParameterSpec
+                                .builder(
+                                    METHOD_PARAMETER_NAME,
+                                    LambdaTypeName.get(
+                                        parameters = genericClassNameInfo.toParameterSpecList(),
+                                        returnType = UNIT
+                                    )
+                                )
+                                .addModifiers(KModifier.NOINLINE)
+                                .build()
+                        )
+                    )
+                    .addCode(
+                        CodeBlock.of(
+                            """ 
+                                val connector = %T.createUnsafe(
+                                    this, 
+                                    $METHOD_PARAMETER_NAME.%M()
+                                )
+                                connector.connect($FLAGS_PARAMETER_NAME)
+                                return connector
+                            """.trimIndent(),
+                            GODOT_SIGNAL_CONNECTOR,
+                            asCallableMember
+                        )
+                    )
+                    .returns(
+                        GODOT_SIGNAL_CONNECTOR
+                    )
+                    .build()
+            )
+
+
+            val lambdaTypeName = genericClassNameInfo.toLambdaTypeName(UNIT, godotObjectBoundTypeVariable)
+
+            connectorFileSpec.addFunction(
+                genericClassNameInfo
+                    .toExtensionFunSpecBuilder(CONNECT_METHOD_METHOD_NAME, listOf(godotObjectBoundTypeVariable))
+                    .addParameters(
+                        listOf(
+                            ParameterSpec
+                                .builder(TARGET_PARAMETER_NAME, godotObjectBoundTypeVariable)
+                                .build(),
+                            ParameterSpec
+                                .builder(METHOD_PARAMETER_NAME, lambdaTypeName)
+                                .build(),
+                            flagsParameter
+                        )
+                    )
+                    .returns(GODOT_SIGNAL_CONNECTOR)
+                    .addCode(
+                        CodeBlock.of(
+                            """ 
+                                val connector = %T.createUnsafe(
+                                    this, 
+                                    %T($TARGET_PARAMETER_NAME,·($METHOD_PARAMETER_NAME·as·%T<*>).name.%M())
+                                )
+                                connector.connect($FLAGS_PARAMETER_NAME)
+                                return connector
+                            """.trimIndent(),
+                            GODOT_SIGNAL_CONNECTOR,
+                            GODOT_METHOD_CALLABLE,
+                            KCallable::class.asClassName(),
+                            TO_GODOT_NAME_UTIL_FUNCTION,
+                        )
+                    )
+                    .addAnnotation(JvmSynthetic::class)
+                    .build()
+            )
+
+            val lambdaContainerClassName = ClassName(godotCorePackage, "$LAMBDA_CONTAINER_NAME$argCount")
+            val containerInfo = GenericClassNameInfo(lambdaContainerClassName, argCount)
+            connectorFileSpec.addFunction(
+                genericClassNameInfo
+                    .toReifiedExtensionFunSpecBuilder(PROMISE_METHOD_NAME)
+                    .addParameters(
+                        listOf(
+                            ParameterSpec
+                                .builder(
+                                    METHOD_PARAMETER_NAME,
+                                    LambdaTypeName.get(
+                                        parameters = genericClassNameInfo.toParameterSpecList(),
+                                        returnType = UNIT
+                                    )
+                                )
+                                .addModifiers(KModifier.NOINLINE)
+                                .build(),
+                            ParameterSpec
+                                .builder(
+                                    CANCEL_PARAMETER_NAME, LambdaTypeName.get(
+                                        returnType = UNIT
+                                    )
+                                )
+                                .addModifiers(KModifier.NOINLINE)
+                                .build(),
+
+                            )
+                    )
+                    .addCode(
+                        CodeBlock.of(
+                            buildString {
+                                append("%T(%T.NIL,·arrayOf(")
+                                genericParameters.forEachIndexed { index, _ ->
+                                    if (index != 0) append(",·")
+                                    append("%M[%T::class]!!")
+                                }
+                                append("),·$METHOD_PARAMETER_NAME).setAsCancellable(this,·$CANCEL_PARAMETER_NAME)")
+                            },
+                            containerInfo.className.parameterizedBy(listOf(UNIT) + containerInfo.genericTypes),
+                            variantConverterClassName,
+                            *genericParameters
+                                .flatMap {
+                                    listOf(variantMapperMember, it)
+                                }
+                                .toTypedArray()
+                        )
+                    )
+                    .build()
+            )
+        }
+
+        connectorFileSpec
+            .addAnnotation(
+                AnnotationSpec
+                    .builder(ClassName("kotlin", "Suppress"))
+                    .addMember("\"PackageDirectoryMismatch\", \"UNCHECKED_CAST\"")
+                    .addMember("\"unused\"")
+                    .addMember("\"NOTHING_TO_INLINE\"")
+                    .build()
+            )
+            .build()
+            .writeTo(output)
+    }
+}
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/LambdaCallableGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/LambdaCallableGenerationService.kt
deleted file mode 100644
index fa09b2509..000000000
--- a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/LambdaCallableGenerationService.kt
+++ /dev/null
@@ -1,444 +0,0 @@
-package godot.codegen.services.impl
-
-import com.squareup.kotlinpoet.ANY
-import com.squareup.kotlinpoet.AnnotationSpec
-import com.squareup.kotlinpoet.ClassName
-import com.squareup.kotlinpoet.CodeBlock
-import com.squareup.kotlinpoet.FileSpec
-import com.squareup.kotlinpoet.FunSpec
-import com.squareup.kotlinpoet.KModifier
-import com.squareup.kotlinpoet.LambdaTypeName
-import com.squareup.kotlinpoet.MemberName
-import com.squareup.kotlinpoet.ParameterSpec
-import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
-import com.squareup.kotlinpoet.PropertySpec
-import com.squareup.kotlinpoet.TypeSpec
-import com.squareup.kotlinpoet.TypeVariableName
-import com.squareup.kotlinpoet.UNIT
-import godot.codegen.poet.GenericClassNameInfo
-import godot.codegen.services.ILambdaCallableGenerationService
-import godot.common.constants.Constraints
-import godot.tools.common.constants.GodotFunctions
-import godot.tools.common.constants.GodotKotlinJvmTypes
-import godot.tools.common.constants.VARIANT_PARSER_NIL
-import godot.tools.common.constants.godotCorePackage
-import godot.tools.common.constants.godotInteropPackage
-import java.io.File
-
-
-object LambdaCallableGenerationService : ILambdaCallableGenerationService {
-    private const val FUNCTION_PARAMETER_NAME = "function"
-    private const val LAMBDA_CALLABLE_NAME = "LambdaCallable"
-    private const val CALLABLE_FUNCTION_NAME = "callable"
-    private const val JAVA_CREATE_METHOD_NAME = "javaCreate"
-    private const val VARIANT_TYPE_ARGUMENT_NAME = "variantConverter"
-    private const val ON_CANCEL_CALL_ARGUMENT_NAME = "onCancelCall"
-    private val LAMBDA_CALLABLE_CLASS_NAME = ClassName(godotCorePackage, LAMBDA_CALLABLE_NAME)
-    private val returnTypeParameter = TypeVariableName("R", ANY.copy(nullable = true))
-
-    //Java
-    private val REFLECTION_CLASS_NAME = ClassName("kotlin.jvm.internal", "Reflection")
-    private val JAVA_CLASS_CLASS_NAME = ClassName("java.lang", "Class")
-
-    override fun generate(outputDir: File) {
-        val callableFileSpec = FileSpec.builder(godotCorePackage, "Callables")
-
-        val onDestroyCallLambdaType = LambdaTypeName.get(returnType = UNIT).copy(nullable = true)
-
-        for (argCount in 0..Constraints.MAX_FUNCTION_ARG_COUNT) {
-            val ktCallableClassName = ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME$argCount")
-            val classBuilder = TypeSpec
-                .classBuilder(ktCallableClassName)
-                .superclass(
-                    LAMBDA_CALLABLE_CLASS_NAME
-                        .parameterizedBy(returnTypeParameter)
-                )
-
-            val argumentRange = 0..<argCount
-
-            classBuilder.addSuperclassConstructorParameter(VARIANT_TYPE_ARGUMENT_NAME)
-            classBuilder.addSuperclassConstructorParameter(ON_CANCEL_CALL_ARGUMENT_NAME)
-
-            for (index in argumentRange) {
-                classBuilder.addSuperclassConstructorParameter("p${index}Type")
-            }
-
-            val typeVariableNames = argumentRange
-                .map {
-                    TypeVariableName("P$it")
-                }
-
-            classBuilder
-                .addTypeVariables(
-                    typeVariableNames
-                )
-                .addTypeVariable(returnTypeParameter)
-
-            val primaryConstructor = FunSpec.constructorBuilder()
-
-            val lambdaTypeName = LambdaTypeName.get(
-                receiver = null,
-                parameters = typeVariableNames
-                    .mapIndexed { index: Int, typeVariableName: TypeVariableName ->
-                        ParameterSpec.builder("p$index", typeVariableName).build()
-                    },
-                returnType = returnTypeParameter
-            )
-
-            classBuilder
-                .addProperty(
-                    PropertySpec
-                        .builder(
-                            FUNCTION_PARAMETER_NAME,
-                            lambdaTypeName,
-                            KModifier.PRIVATE
-                        )
-                        .initializer(FUNCTION_PARAMETER_NAME)
-                        .build()
-                )
-
-            val variantConverterClassName = ClassName(
-                godotInteropPackage,
-                GodotKotlinJvmTypes.variantConverter
-            )
-
-            primaryConstructor
-                .addParameter(
-                    ParameterSpec
-                        .builder(
-                            VARIANT_TYPE_ARGUMENT_NAME,
-                            variantConverterClassName
-                        )
-                        .build()
-                )
-
-            for (arg in argumentRange) {
-                val typeProperty = "p${arg}Type"
-
-                if (arg != argumentRange.last) {
-                    classBuilder
-                        .addProperty(
-                            PropertySpec
-                                .builder(
-                                    typeProperty,
-                                    variantConverterClassName,
-                                    KModifier.PRIVATE
-                                )
-                                .initializer(typeProperty)
-                                .build()
-                        )
-                }
-
-                primaryConstructor
-                    .addParameter(
-                        ParameterSpec
-                            .builder(
-                                typeProperty,
-                                variantConverterClassName
-                            )
-                            .build()
-                    )
-            }
-
-            primaryConstructor
-                .addParameter(
-                    ParameterSpec
-                        .builder(
-                            ON_CANCEL_CALL_ARGUMENT_NAME,
-                            onDestroyCallLambdaType
-                        )
-                        .defaultValue("null")
-                        .build()
-                )
-
-            primaryConstructor
-                .addParameter(
-                    ParameterSpec
-                        .builder(
-                            FUNCTION_PARAMETER_NAME,
-                            lambdaTypeName
-                        )
-                        .build()
-                )
-                .addModifiers(KModifier.INTERNAL)
-                .addAnnotation(PublishedApi::class)
-
-            classBuilder.primaryConstructor(primaryConstructor.build())
-
-            classBuilder
-                .addFunction(
-                    FunSpec.builder("invokeKt")
-                        .returns(
-                            returnTypeParameter
-                        )
-                        .addCode(
-                            CodeBlock.of(
-                                buildString {
-                                    append("return·$FUNCTION_PARAMETER_NAME(")
-                                    for (i in argumentRange) {
-                                        if (i != 0) append(",·")
-
-                                        append("paramsArray[$i]·as·%T")
-                                    }
-                                    append(')')
-                                },
-                                *typeVariableNames.toTypedArray()
-                            )
-                        )
-                        .addModifiers(KModifier.OVERRIDE)
-                        .build()
-                )
-
-            classBuilder
-                .addFunction(
-                    FunSpec.builder("invoke")
-                        .returns(
-                            returnTypeParameter
-                        )
-                        .addParameters(
-                            typeVariableNames
-                                .mapIndexed { index: Int, typeVariableName: TypeVariableName ->
-                                    ParameterSpec.builder("p$index", typeVariableName)
-                                        .build()
-                                }
-                        )
-                        .addCode(
-                            CodeBlock.of(
-                                buildString {
-                                    append("return·$FUNCTION_PARAMETER_NAME(")
-                                    for (i in argumentRange) {
-                                        if (i != 0) append(",·")
-
-                                        append("p$i")
-                                    }
-                                    append(')')
-                                }
-                            )
-                        )
-                        .addModifiers(KModifier.OPERATOR)
-                        .build()
-                )
-
-            classBuilder
-                .addFunction(
-                    FunSpec.builder("call")
-                        .returns(ANY.copy(nullable = true))
-                        .addParameter(
-                            ParameterSpec.builder("args", ANY.copy(nullable = true))
-                                .addModifiers(KModifier.VARARG)
-                                .build()
-                        )
-                        .addCode(
-                            CodeBlock.of(
-                                buildString {
-                                    append("return·$FUNCTION_PARAMETER_NAME(")
-                                    for (i in argumentRange) {
-                                        if (i != 0) append(",·")
-
-                                        append("args[$i]·as·%T")
-                                    }
-                                    append(')')
-                                },
-                                *typeVariableNames.toTypedArray()
-                            )
-                        )
-                        .addModifiers(KModifier.OVERRIDE)
-                        .build()
-                )
-
-            val typeVariables = typeVariableNames.toMutableList()
-            var removedTypeVariables = 0
-            while (typeVariables.isNotEmpty()) {
-                val bindReturnType =
-                    ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME${typeVariableNames.size - typeVariables.size}")
-                classBuilder.addFunction(
-                    FunSpec.builder("bind")
-                        .addParameters(
-                            typeVariables
-                                .mapIndexed { index: Int, typeVariableName: TypeVariableName ->
-                                    ParameterSpec.builder("p${index + removedTypeVariables}", typeVariableName)
-                                        .build()
-                                }
-                        )
-                        .addCode(
-                            buildString {
-                                append("return·%T($VARIANT_TYPE_ARGUMENT_NAME")
-
-                                for (index in (0..<removedTypeVariables)) {
-                                    append(",·p${index}Type")
-                                }
-
-                                append(",·$ON_CANCEL_CALL_ARGUMENT_NAME")
-
-                                append(")·{·")
-
-                                for (index in (0..<removedTypeVariables)) {
-                                    if (index != 0) append(",·")
-
-                                    append("p${index}:·%T")
-                                }
-
-                                append("·->·$FUNCTION_PARAMETER_NAME(")
-
-                                for (i in typeVariableNames.indices) {
-                                    if (i != 0) append(",·")
-
-                                    append("p$i")
-                                }
-
-                                append(")·}")
-                            },
-                            bindReturnType,
-                            *typeVariableNames.take(removedTypeVariables).toTypedArray()
-                        )
-                        .build()
-                )
-
-                typeVariables.removeFirst()
-                ++removedTypeVariables
-            }
-
-            val genericClassNameInfo = GenericClassNameInfo(ktCallableClassName, argCount)
-            classBuilder.addType(generateKtCallableCompanion(argCount, genericClassNameInfo))
-
-            callableFileSpec.addType(classBuilder.build())
-
-            val variantMapperMember = MemberName(godotCorePackage, "variantMapper")
-            callableFileSpec.addFunction(
-                FunSpec.builder(CALLABLE_FUNCTION_NAME + argCount)
-                    .addTypeVariables(typeVariableNames.map { it.copy(reified = true) })
-                    .addTypeVariable(returnTypeParameter.copy(reified = true))
-                    .addModifiers(KModifier.INLINE)
-                    .addParameters(
-                        listOf(
-                            ParameterSpec
-                                .builder(ON_CANCEL_CALL_ARGUMENT_NAME, onDestroyCallLambdaType)
-                                .addModifiers(KModifier.NOINLINE)
-                                .defaultValue("null")
-                                .build(),
-                            ParameterSpec
-                                .builder(
-                                    FUNCTION_PARAMETER_NAME,
-                                    lambdaTypeName
-                                )
-                                .addModifiers(KModifier.NOINLINE)
-                                .build()
-                        )
-                    )
-                    .addCode(
-                        CodeBlock.of(
-                            buildString {
-                                append("return·$LAMBDA_CALLABLE_NAME$argCount(")
-                                append("%M.getOrDefault(%T::class,·%T),·")
-                                for (typeParameter in typeVariableNames) {
-                                    append("%M[%T::class]!!,·")
-                                }
-                                append("$ON_CANCEL_CALL_ARGUMENT_NAME,·")
-                                append(FUNCTION_PARAMETER_NAME)
-                                append(')')
-                            },
-                            variantMapperMember,
-                            returnTypeParameter,
-                            VARIANT_PARSER_NIL,
-                            *typeVariableNames
-                                .flatMap {
-                                    listOf(variantMapperMember, it)
-                                }
-                                .toTypedArray()
-                        )
-                    )
-                    .build()
-            )
-
-            callableFileSpec
-                .addFunction(
-                    FunSpec
-                        .builder(GodotFunctions.asCallable)
-                        .addTypeVariables(typeVariableNames.map { it.copy(reified = true) })
-                        .addTypeVariable(returnTypeParameter.copy(reified = true))
-                        .addModifiers(KModifier.INLINE)
-                        .receiver(lambdaTypeName)
-                        .addParameter(
-                            ParameterSpec
-                                .builder(ON_CANCEL_CALL_ARGUMENT_NAME, onDestroyCallLambdaType)
-                                .addModifiers(KModifier.NOINLINE)
-                                .defaultValue("null")
-                                .build()
-                        )
-                        .addCode("return·$CALLABLE_FUNCTION_NAME$argCount($ON_CANCEL_CALL_ARGUMENT_NAME,·this)")
-                        .build()
-                )
-        }
-
-        callableFileSpec.addAnnotation(
-            AnnotationSpec.builder(ClassName("kotlin", "Suppress"))
-                .addMember("\"PackageDirectoryMismatch\", \"UNCHECKED_CAST\"")
-                .build()
-        )
-            .build()
-            .writeTo(outputDir)
-    }
-
-    // JAVA BRIDGE FUNCTION
-    private fun generateKtCallableCompanion(argCount: Int, genericClassNameInfo: GenericClassNameInfo): TypeSpec {
-        val variantMapperMember = MemberName(godotCorePackage, "variantMapper")
-
-        return TypeSpec
-            .companionObjectBuilder()
-            .addFunction(
-                FunSpec
-                    .builder(JAVA_CREATE_METHOD_NAME)
-                    .addTypeVariable(returnTypeParameter)
-                    .addTypeVariables(genericClassNameInfo.genericTypes)
-                    .addParameter(
-                        ParameterSpec
-                            .builder("returnClass", JAVA_CLASS_CLASS_NAME.parameterizedBy(returnTypeParameter))
-                            .build()
-                    )
-                    .addParameters(genericClassNameInfo.toParameterSpecList().map {
-                        ParameterSpec
-                            .builder(it.name + "Class", JAVA_CLASS_CLASS_NAME.parameterizedBy(it.type))
-                            .build()
-                    })
-                    .addParameter(
-                        ParameterSpec
-                            .builder(
-                                FUNCTION_PARAMETER_NAME,
-                                genericClassNameInfo.toLambdaTypeName(returnTypeParameter)
-                            )
-                            .build()
-                    )
-                    .addCode(
-                        CodeBlock.of(
-                            buildString {
-                                append("return·$LAMBDA_CALLABLE_NAME$argCount(")
-                                append("%M.getOrDefault(%T.getOrCreateKotlinClass(returnClass),·%T),·")
-                                genericClassNameInfo.toParameterSpecList().forEach {
-                                    append("%M[%T.getOrCreateKotlinClass(${it.name}Class)]!!,·")
-                                }
-                                append("null,·")
-                                append(FUNCTION_PARAMETER_NAME)
-                                append(')')
-                            },
-                            variantMapperMember,
-                            REFLECTION_CLASS_NAME,
-                            VARIANT_PARSER_NIL,
-                            *genericClassNameInfo.genericTypes
-                                .flatMap {
-                                    listOf(variantMapperMember, REFLECTION_CLASS_NAME)
-                                }
-                                .toTypedArray()
-                        )
-                    )
-                    .addAnnotation(JvmStatic::class)
-                    .addAnnotation(
-                        AnnotationSpec
-                            .builder(JvmName::class)
-                            .addMember("\"create\"")
-                            .build()
-                    )
-                    .build()
-            )
-            .build()
-    }
-}
diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/SignalGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/SignalGenerationService.kt
index 173454e9b..342d5475e 100644
--- a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/SignalGenerationService.kt
+++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/SignalGenerationService.kt
@@ -1,62 +1,51 @@
 package godot.codegen.services.impl
 
-import com.squareup.kotlinpoet.ANY
 import com.squareup.kotlinpoet.AnnotationSpec
 import com.squareup.kotlinpoet.ClassName
 import com.squareup.kotlinpoet.CodeBlock
 import com.squareup.kotlinpoet.FileSpec
 import com.squareup.kotlinpoet.FunSpec
-import com.squareup.kotlinpoet.INT
 import com.squareup.kotlinpoet.KModifier
-import com.squareup.kotlinpoet.LambdaTypeName
 import com.squareup.kotlinpoet.ParameterSpec
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
 import com.squareup.kotlinpoet.PropertySpec
 import com.squareup.kotlinpoet.STAR
 import com.squareup.kotlinpoet.STRING
 import com.squareup.kotlinpoet.TypeSpec
-import com.squareup.kotlinpoet.TypeVariableName
 import com.squareup.kotlinpoet.UNIT
-import com.squareup.kotlinpoet.asClassName
 import godot.codegen.poet.GenericClassNameInfo
 import godot.codegen.services.ISignalGenerationService
 import godot.common.constants.Constraints
-import godot.tools.common.constants.AS_CALLABLE_UTIL_FUNCTION
-import godot.tools.common.constants.GODOT_CALLABLE
-import godot.tools.common.constants.GODOT_ERROR
 import godot.tools.common.constants.GODOT_OBJECT
+import godot.tools.common.constants.STRING_NAME
 import godot.tools.common.constants.TO_GODOT_NAME_UTIL_FUNCTION
 import godot.tools.common.constants.godotCorePackage
-import godot.tools.common.constants.godotExtensionPackage
 import godot.tools.common.constants.kotlinReflectPackage
 import java.io.File
-import kotlin.reflect.KCallable
 
 object SignalGenerationService : ISignalGenerationService {
-
+    private const val CALLABLE_NAME = "Callable"
     private const val SIGNAL_CLASS_NAME = "Signal"
+
     private const val INSTANCE_PARAMETER = "instance"
     private const val NAME_PARAMETER = "name"
     private const val PROPERTY_PARAMETER = "property"
-    private const val TARGET_PARAMETER_NAME = "target"
-    private const val METHOD_PARAMETER_NAME = "method"
-    private const val FLAGS_PARAMETER_NAME = "flags"
     private const val THIS_REF_PARAMETER_NAME = "thisRef"
+    private const val CONNECT_PARAMETER_NAME = "connect"
 
     private const val EMIT_METHOD_NAME = "emit"
     private const val CONNECT_METHOD_NAME = "connect"
-    private const val CONNECT_THREAD_SAFE_METHOD_NAME = "connectThreadSafe"
-    private const val DISCONNECT_METHOD_NAME = "disconnect"
     private const val SIGNAL_METHOD_NAME = "signal"
-    private const val JAVA_CREATE_METHOD_NAME = "javaCreate"
+    private const val FLAGS_PARAMETER_NAME = "flags"
 
+    private const val UNSAFE_SUFFIX = "Unsafe"
     private const val DELEGATE_PROPERTY_NAME = "delegate"
 
+    private val connectFlagClassName = ClassName(godotCorePackage, "Object.ConnectFlags")
     private val propertyClassname = ClassName(kotlinReflectPackage, "KProperty").parameterizedBy(STAR)
     private val readOnlyPropertyClassName = ClassName("kotlin.properties", "ReadOnlyProperty")
-    private val godotObjectBoundTypeVariable = TypeVariableName("T", GODOT_OBJECT)
 
-    override fun generateCore(outputDir: File) {
+    override fun generate(outputDir: File) {
         val signalFileSpec = FileSpec.builder(godotCorePackage, "Signals")
 
         for (argCount in 0..Constraints.MAX_FUNCTION_ARG_COUNT) {
@@ -67,7 +56,6 @@ object SignalGenerationService : ISignalGenerationService {
 
             signalFileSpec.addFunction(generateFakeSignalConstructor(argCount, genericClassNameInfo))
             signalFileSpec.addFunction(generateSignalDelegate(argCount, genericClassNameInfo))
-            signalFileSpec.addFunction(generateSignalExtension(genericClassNameInfo, false))
         }
 
         signalFileSpec
@@ -77,6 +65,7 @@ object SignalGenerationService : ISignalGenerationService {
                     .addMember("\"PackageDirectoryMismatch\"")
                     .addMember("\"NOTHING_TO_INLINE\"")
                     .addMember("\"UNUSED_PARAMETER\"")
+                    .addMember("\"unused\"")
                     .build()
             )
             .indent("    ")
@@ -84,48 +73,8 @@ object SignalGenerationService : ISignalGenerationService {
             .writeTo(outputDir)
     }
 
-    override fun generateExtension(outputDir: File) {
-        val signalFileSpec = FileSpec.builder(godotExtensionPackage, "SignalUtils")
-
-        for (argCount in 0..Constraints.MAX_FUNCTION_ARG_COUNT) {
-            val signalClassName = ClassName(godotCorePackage, "$SIGNAL_CLASS_NAME$argCount")
-            val genericClassNameInfo = GenericClassNameInfo(signalClassName, argCount)
-
-            signalFileSpec.addFunction(generateThreadSafeExtension(argCount, genericClassNameInfo))
-            signalFileSpec.addFunction(generateSignalExtension(genericClassNameInfo, true))
-        }
-
-        signalFileSpec
-            .addAnnotation(
-                AnnotationSpec
-                    .builder(Suppress::class)
-                    .addMember("\"PackageDirectoryMismatch\"")
-                    .addMember("\"NOTHING_TO_INLINE\"")
-                    .addMember("\"UNUSED_PARAMETER\"")
-                    .build()
-            )
-            .indent("    ")
-            .addImport(
-                "godot.extension",
-                "connectThreadSafe"
-            )
-            .build()
-            .writeTo(outputDir)
-    }
-
-
     private fun generateSignalClass(argCount: Int, genericClassNameInfo: GenericClassNameInfo): TypeSpec {
-
-        val flagsParameter = ParameterSpec.builder(FLAGS_PARAMETER_NAME, INT)
-            .defaultValue("0")
-            .build()
-
-        val lambdaTypeName = LambdaTypeName.get(
-            receiver = godotObjectBoundTypeVariable,
-            parameters = genericClassNameInfo.toParameterSpecList(),
-            returnType = UNIT
-        )
-
+        val callableClassName = ClassName(godotCorePackage, CALLABLE_NAME + argCount)
         return genericClassNameInfo
             .toTypeSpecBuilder()
             .superclass(ClassName(godotCorePackage, SIGNAL_CLASS_NAME))
@@ -135,7 +84,7 @@ object SignalGenerationService : ISignalGenerationService {
                     .addParameters(
                         listOf(
                             ParameterSpec.builder(INSTANCE_PARAMETER, GODOT_OBJECT).build(),
-                            ParameterSpec.builder(NAME_PARAMETER, STRING).build()
+                            ParameterSpec.builder(NAME_PARAMETER, STRING_NAME).build()
                         )
                     )
                     .addAnnotation(PublishedApi::class)
@@ -153,7 +102,7 @@ object SignalGenerationService : ISignalGenerationService {
                         .addCode(
                             CodeBlock.of(
                                 buildString {
-                                    append("emitSignal(")
+                                    append("$EMIT_METHOD_NAME$UNSAFE_SUFFIX(")
                                     for (i in 0..<argCount) {
                                         if (i != 0) append(",·")
                                         append("p$i")
@@ -163,82 +112,31 @@ object SignalGenerationService : ISignalGenerationService {
                             )
                         )
                         .build(),
-
                     FunSpec.builder(CONNECT_METHOD_NAME)
-                        .addTypeVariable(godotObjectBoundTypeVariable)
+                        .returns(UNIT)
                         .addParameters(
                             listOf(
-                                ParameterSpec.builder(TARGET_PARAMETER_NAME, godotObjectBoundTypeVariable).build(),
-                                ParameterSpec.builder(METHOD_PARAMETER_NAME, lambdaTypeName).build(),
-                                flagsParameter
+                                ParameterSpec.builder(
+                                    CONNECT_PARAMETER_NAME,
+                                    callableClassName.parameterizedBy(listOf(STAR) + genericClassNameInfo.genericTypes)
+                                ).build(),
+                                ParameterSpec.builder(FLAGS_PARAMETER_NAME, connectFlagClassName)
+                                    .defaultValue("%T.%L", connectFlagClassName, "DEFAULT")
+                                    .build()
                             )
                         )
-                        .returns(GODOT_ERROR)
-                        .addCode(generateConnectionCodeBlock())
-                        .build(),
-
-                    FunSpec.builder(DISCONNECT_METHOD_NAME)
-                        .addTypeVariable(godotObjectBoundTypeVariable)
-                        .addParameters(
-                            listOf(
-                                ParameterSpec.builder(TARGET_PARAMETER_NAME, godotObjectBoundTypeVariable).build(),
-                                ParameterSpec.builder(METHOD_PARAMETER_NAME, lambdaTypeName).build()
+                        .addCode(
+                            CodeBlock.of(
+                                "connectUnsafe($CONNECT_PARAMETER_NAME, $FLAGS_PARAMETER_NAME)"
                             )
                         )
-                        .returns(UNIT)
-                        .addCode(generateConnectionCodeBlock(true))
-                        .build()
+                        .build(),
                 )
             )
             .addType(generateSignalCompanion(argCount, genericClassNameInfo))
             .build()
     }
 
-    private fun generateThreadSafeExtension(argCount: Int, genericClassNameInfo: GenericClassNameInfo): FunSpec {
-        val flagsParameter = ParameterSpec.builder(FLAGS_PARAMETER_NAME, INT)
-            .defaultValue("0")
-            .build()
-
-        val lambdaTypeName = LambdaTypeName.get(
-            receiver = godotObjectBoundTypeVariable,
-            parameters = genericClassNameInfo.toParameterSpecList(),
-            returnType = UNIT
-        )
-
-        return genericClassNameInfo
-            .toExtensionFunSpecBuilder(CONNECT_THREAD_SAFE_METHOD_NAME)
-            .addTypeVariable(godotObjectBoundTypeVariable)
-            .addParameters(
-                listOf(
-                    ParameterSpec.builder(TARGET_PARAMETER_NAME, godotObjectBoundTypeVariable).build(),
-                    ParameterSpec.builder(METHOD_PARAMETER_NAME, lambdaTypeName).build(),
-                    flagsParameter
-                )
-            )
-            .returns(ANY.copy(nullable = true))
-            .addCode(generateConnectionCodeBlock(false, true))
-            .build()
-    }
-
-    private fun generateConnectionCodeBlock(isDisconnect: Boolean = false, isThreadSafe: Boolean = false): CodeBlock {
-        val methodName = if (isDisconnect) {
-            DISCONNECT_METHOD_NAME
-        } else {
-            if (isThreadSafe) {
-                CONNECT_THREAD_SAFE_METHOD_NAME
-            } else {
-                CONNECT_METHOD_NAME
-            }
-        }
-        val flagsParameters = if (isDisconnect) "" else ",·$FLAGS_PARAMETER_NAME"
-
-        return CodeBlock.of(
-            "return·$methodName(%T($TARGET_PARAMETER_NAME,·($METHOD_PARAMETER_NAME·as·%T<*>).name.%M())$flagsParameters)",
-            GODOT_CALLABLE,
-            KCallable::class.asClassName(),
-            TO_GODOT_NAME_UTIL_FUNCTION,
-        )
-    }
 
     private fun generateSignalCompanion(argCount: Int, genericClassNameInfo: GenericClassNameInfo): TypeSpec {
         val erasedReadOnlyPropertyClassName = readOnlyPropertyClassName.parameterizedBy(GODOT_OBJECT, genericClassNameInfo.erasedGenericClassName)
@@ -267,31 +165,13 @@ object SignalGenerationService : ISignalGenerationService {
                     .returns(genericClassNameInfo.genericClassName)
                     .addCode(
                         CodeBlock.of(
-                            "return·%T(thisRef,·property.name)",
+                            "return·%T(thisRef,·property.%M())",
                             genericClassNameInfo.className,
+                            TO_GODOT_NAME_UTIL_FUNCTION
                         )
                     )
                     .build()
             )
-            .addFunction(
-                genericClassNameInfo
-                    .toFunSpecBuilder(JAVA_CREATE_METHOD_NAME)
-                    .addParameter(ParameterSpec.builder("`object`", GODOT_OBJECT).build())
-                    .addParameter(ParameterSpec.builder("signalName", STRING).build())
-                    .returns(genericClassNameInfo.genericClassName)
-                    .addCode(
-                        "return·%T(`object`,·signalName)",
-                        genericClassNameInfo.className
-                    )
-                    .addAnnotation(JvmStatic::class)
-                    .addAnnotation(
-                        AnnotationSpec
-                            .builder(JvmName::class)
-                            .addMember("\"create\"")
-                            .build()
-                    )
-                    .build()
-            )
             .build()
     }
 
@@ -304,8 +184,9 @@ object SignalGenerationService : ISignalGenerationService {
             .addParameter(ParameterSpec.builder("signalName", STRING).build())
             .addCode(
                 CodeBlock.of(
-                    "return·%T(this,·signalName)",
+                    "return·%T(this,·signalName.%M())",
                     genericClassNameInfo.genericClassName,
+                    TO_GODOT_NAME_UTIL_FUNCTION
                 )
             )
             .addAnnotation(
@@ -343,48 +224,4 @@ object SignalGenerationService : ISignalGenerationService {
             }
             .build()
     }
-
-
-    private fun generateSignalExtension(genericClassNameInfo: GenericClassNameInfo, isThreadSafe: Boolean): FunSpec {
-        val flagsParameter = ParameterSpec.builder(FLAGS_PARAMETER_NAME, INT)
-            .defaultValue("0")
-            .build()
-
-        val signalConnectExtensionGenericParameters = ParameterSpec.builder(
-            METHOD_PARAMETER_NAME,
-            LambdaTypeName.get(
-                parameters = genericClassNameInfo.toParameterSpecList(),
-                returnType = UNIT
-            )
-        )
-            .addModifiers(KModifier.NOINLINE)
-            .build()
-
-        val methodName = if (isThreadSafe) {
-            CONNECT_THREAD_SAFE_METHOD_NAME
-        } else {
-            CONNECT_METHOD_NAME
-        }
-
-        return genericClassNameInfo
-            .toReifiedExtensionFunSpecBuilder(methodName)
-            .addParameters(
-                listOf(
-                    flagsParameter,
-                    signalConnectExtensionGenericParameters
-                )
-            )
-            .addCode(
-                "return·$methodName($METHOD_PARAMETER_NAME.%M(),·$FLAGS_PARAMETER_NAME)",
-                AS_CALLABLE_UTIL_FUNCTION
-            )
-            .returns(
-                if (isThreadSafe) {
-                    ANY.copy(nullable = true)
-                } else {
-                    GODOT_ERROR
-                }
-            )
-            .build()
-    }
 }
diff --git a/kt/api-generator/src/main/kotlin/godot/gradle/ApiGeneratorPlugin.kt b/kt/api-generator/src/main/kotlin/godot/gradle/ApiGeneratorPlugin.kt
index cb4f8f783..d3757fb7e 100644
--- a/kt/api-generator/src/main/kotlin/godot/gradle/ApiGeneratorPlugin.kt
+++ b/kt/api-generator/src/main/kotlin/godot/gradle/ApiGeneratorPlugin.kt
@@ -2,7 +2,6 @@ package godot.gradle
 
 import godot.codegen.generateApiFrom
 import godot.codegen.generateCoroutine
-import godot.codegen.generateExtension
 import org.gradle.api.DefaultTask
 import org.gradle.api.Plugin
 import org.gradle.api.Project
@@ -43,16 +42,16 @@ open class GenerateAPI : DefaultTask() {
         val apiOutput = apiOutputDir.get().asFile
         apiOutput.deleteRecursively()
 
+        val extensionOutput = extensionOutputDir.get().asFile
+        extensionOutput.deleteRecursively()
+
         generateApiFrom(
             sourceJson.get().asFile,
             coreOutput,
             apiOutput,
+            extensionOutput
         )
 
-        val extensionOutput = extensionOutputDir.get().asFile
-        extensionOutput.deleteRecursively()
-        generateExtension(extensionOutput)
-
         val coroutineOutput = coroutineOutputDir.get().asFile
         coroutineOutput.deleteRecursively()
         generateCoroutine(coroutineOutput)
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/api/Object.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/api/Object.kt
index 170acade1..592aa1163 100644
--- a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/api/Object.kt
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/api/Object.kt
@@ -995,9 +995,9 @@ public open class Object : KtObject() {
   public final fun connect(
     signal: StringName,
     callable: Callable,
-    flags: Long = 0,
+    flags: ConnectFlags = Object.ConnectFlags.DEFAULT,
   ): Error {
-    TransferContext.writeArguments(STRING_NAME to signal, CALLABLE to callable, LONG to flags)
+    TransferContext.writeArguments(STRING_NAME to signal, CALLABLE to callable, LONG to flags.id)
     TransferContext.callMethod(ptr, MethodBindings.connectPtr, LONG)
     return Error.from(TransferContext.readReturnValue(LONG) as Long)
   }
@@ -1740,7 +1740,7 @@ public open class Object : KtObject() {
   public final fun connect(
     signal: String,
     callable: Callable,
-    flags: Long = 0,
+    flags: ConnectFlags = Object.ConnectFlags.DEFAULT,
   ): Error = connect(signal.asCachedStringName(), callable, flags)
 
   /**
@@ -1826,6 +1826,10 @@ public open class Object : KtObject() {
   public enum class ConnectFlags(
     id: Long,
   ) {
+    /**
+     * Default connections that are immediately emitted
+     */
+    DEFAULT(0),
     /**
      * Deferred connections trigger their [Callable]s on idle time (at the end of the frame), rather
      * than instantly.
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Callables.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Callables.kt
index 9a583a300..700bbcae8 100644
--- a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Callables.kt
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Callables.kt
@@ -1,295 +1,136 @@
-@file:Suppress("PackageDirectoryMismatch", "UNCHECKED_CAST")
+@file:Suppress(
+  "PackageDirectoryMismatch", "UNCHECKED_CAST",
+  "unused",
+)
 
 package godot.core
 
-import godot.common.interop.VariantConverter
-import godot.core.VariantParser.NIL
-import java.lang.Class
-import kotlin.Any
-import kotlin.PublishedApi
 import kotlin.Suppress
-import kotlin.Unit
-import kotlin.jvm.JvmName
-import kotlin.jvm.JvmStatic
-import kotlin.jvm.`internal`.Reflection
-
-public class LambdaCallable0<R> @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: () -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall) {
-  public override fun invokeKt(): R = function()
-
-  public operator fun invoke(): R = function()
-
-  public override fun call(vararg args: Any?): Any? = function()
-
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R> javaCreate(returnClass: Class<R>, function: () -> R) =
-        LambdaCallable0(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), null, function)
-  }
-}
 
-public inline fun <reified R> callable0(noinline onCancelCall: (() -> Unit)? = null, noinline
-    function: () -> R) =
-    LambdaCallable0(variantMapper.getOrDefault(R::class, NIL), onCancelCall, function)
-
-public inline fun <reified R> (() -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) =
-    callable0(onCancelCall, this)
-
-public class LambdaCallable1<P0, R> @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  p0Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (p0: P0) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type) {
-  public override fun invokeKt(): R = function(paramsArray[0] as P0)
-
-  public operator fun invoke(p0: P0): R = function(p0)
-
-  public override fun call(vararg args: Any?): Any? = function(args[0] as P0)
-
-  public fun bind(p0: P0) = LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0) }
-
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      function: (p0: P0) -> R,
-    ) =
-        LambdaCallable1(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, null, function)
-  }
+public interface Callable0<R> : Callable {
+  public fun call(): R = callUnsafe() as R
+
+  public fun callDeferred() = callDeferredUnsafe()
+
+  public operator fun invoke(): R = call()
 }
 
-public inline fun <reified P0, reified R> callable1(noinline onCancelCall: (() -> Unit)? = null,
-    noinline function: (p0: P0) -> R) =
-    LambdaCallable1(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified R> ((p0: P0) -> R).asCallable(noinline
-    onCancelCall: (() -> Unit)? = null) = callable1(onCancelCall, this)
-
-public class LambdaCallable2<P0, P1, R> @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  p1Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (p0: P0, p1: P1) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type) {
-  public override fun invokeKt(): R = function(paramsArray[0] as P0, paramsArray[1] as P1)
-
-  public operator fun invoke(p0: P0, p1: P1): R = function(p0, p1)
-
-  public override fun call(vararg args: Any?): Any? = function(args[0] as P0, args[1] as P1)
-
-  public fun bind(p0: P0, p1: P1) =
-      LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1) }
-
-  public fun bind(p1: P1) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1) }
-
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      function: (p0: P0, p1: P1) -> R,
-    ) =
-        LambdaCallable2(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, null, function)
-  }
+public interface Callable1<R, P0> : Callable {
+  public fun call(p0: P0): R = callUnsafe(p0) as R
+
+  public fun callDeferred(p0: P0) = callDeferredUnsafe(p0)
+
+  public operator fun invoke(p0: P0): R = call(p0)
+
+  public fun bind(p0: P0): Callable0<R>
 }
 
-public inline fun <reified P0, reified P1, reified R> callable2(noinline onCancelCall: (() -> Unit)?
-    = null, noinline function: (p0: P0, p1: P1) -> R) =
-    LambdaCallable2(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, onCancelCall, function)
+public interface Callable2<R, P0, P1> : Callable {
+  public fun call(p0: P0, p1: P1): R = callUnsafe(p0, p1) as R
 
-public inline fun <reified P0, reified P1, reified R> ((p0: P0, p1: P1) -> R).asCallable(noinline
-    onCancelCall: (() -> Unit)? = null) = callable2(onCancelCall, this)
+  public fun callDeferred(p0: P0, p1: P1) = callDeferredUnsafe(p0, p1)
 
-public class LambdaCallable3<P0, P1, P2, R> @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  p2Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+  public operator fun invoke(p0: P0, p1: P1): R = call(p0, p1)
+
+  public fun bind(p0: P0, p1: P1): Callable0<R>
+
+  public fun bind(p1: P1): Callable1<R, P0>
+}
+
+public interface Callable3<R, P0, P1, P2> : Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2)
+  ): R = callUnsafe(p0, p1, p2) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
-  ): R = function(p0, p1, p2)
+  ) = callDeferredUnsafe(p0, p1, p2)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+  ): R = call(p0, p1, p2)
 
   public fun bind(
     p0: P0,
     p1: P1,
     p2: P2,
-  ) = LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2) }
-
-  public fun bind(p1: P1, p2: P2) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2) }
-
-  public fun bind(p2: P2) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2) }
-
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-      ) -> R,
-    ) =
-        LambdaCallable3(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, null, function)
-  }
+  ): Callable0<R>
+
+  public fun bind(p1: P1, p2: P2): Callable1<R, P0>
+
+  public fun bind(p2: P2): Callable2<R, P0, P1>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified R> callable3(noinline
-    onCancelCall: (() -> Unit)? = null, noinline function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-) -> R) =
-    LambdaCallable3(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable3(onCancelCall, this)
-
-public class LambdaCallable4<P0, P1, P2, P3, R> @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  p3Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable4<R, P0, P1, P2, P3> : Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
     p3: P3,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3)
+  ): R = callUnsafe(p0, p1, p2, p3) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
     p3: P3,
-  ): R = function(p0, p1, p2, p3)
+  ) = callDeferredUnsafe(p0, p1, p2, p3)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+  ): R = call(p0, p1, p2, p3)
 
   public fun bind(
     p0: P0,
     p1: P1,
     p2: P2,
     p3: P3,
-  ) = LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
     p2: P2,
     p3: P3,
-  ) = LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3) }
-
-  public fun bind(p2: P2, p3: P3) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3) }
+  ): Callable1<R, P0>
 
-  public fun bind(p3: P3) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3) }
+  public fun bind(p2: P2, p3: P3): Callable2<R, P0, P1>
 
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-      ) -> R,
-    ) =
-        LambdaCallable4(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, null, function)
-  }
+  public fun bind(p3: P3): Callable3<R, P0, P1, P2>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified R> callable4(noinline
-    onCancelCall: (() -> Unit)? = null, noinline function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-) -> R) =
-    LambdaCallable4(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable4(onCancelCall, this)
-
-public class LambdaCallable5<P0, P1, P2, P3, P4, R> @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  private val p3Type: VariantConverter,
-  p4Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable5<R, P0, P1, P2, P3, P4> : Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
     p3: P3,
     p4: P4,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type, p4Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3, paramsArray[4] as P4)
+  ): R = callUnsafe(p0, p1, p2, p3, p4) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
     p3: P3,
     p4: P4,
-  ): R = function(p0, p1, p2, p3, p4)
+  ) = callDeferredUnsafe(p0, p1, p2, p3, p4)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+  ): R = call(p0, p1, p2, p3, p4)
 
   public fun bind(
     p0: P0,
@@ -297,102 +138,53 @@ public class LambdaCallable5<P0, P1, P2, P3, P4, R> @PublishedApi internal const
     p2: P2,
     p3: P3,
     p4: P4,
-  ) = LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3, p4) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
     p2: P2,
     p3: P3,
     p4: P4,
-  ) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3, p4) }
+  ): Callable1<R, P0>
 
   public fun bind(
     p2: P2,
     p3: P3,
     p4: P4,
-  ) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3, p4) }
-
-  public fun bind(p3: P3, p4: P4) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3, p4) }
+  ): Callable2<R, P0, P1>
 
-  public fun bind(p4: P4) =
-      LambdaCallable4(variantConverter, p0Type, p1Type, p2Type, p3Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3 -> function(p0, p1, p2, p3, p4) }
+  public fun bind(p3: P3, p4: P4): Callable3<R, P0, P1, P2>
 
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3, P4> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      p4Class: Class<P4>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-      ) -> R,
-    ) =
-        LambdaCallable5(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p4Class)]!!, null, function)
-  }
+  public fun bind(p4: P4): Callable4<R, P0, P1, P2, P3>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified R>
-    callable5(noinline onCancelCall: (() -> Unit)? = null, noinline function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-) -> R) =
-    LambdaCallable5(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable5(onCancelCall, this)
-
-public class LambdaCallable6<P0, P1, P2, P3, P4, P5, R> @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  private val p3Type: VariantConverter,
-  private val p4Type: VariantConverter,
-  p5Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable6<R, P0, P1, P2, P3, P4, P5> : Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
     p3: P3,
     p4: P4,
     p5: P5,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type, p4Type,
-    p5Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3, paramsArray[4] as P4, paramsArray[5] as P5)
+  ): R = callUnsafe(p0, p1, p2, p3, p4, p5) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
     p3: P3,
     p4: P4,
     p5: P5,
-  ): R = function(p0, p1, p2, p3, p4, p5)
+  ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+  ): R = call(p0, p1, p2, p3, p4, p5)
 
   public fun bind(
     p0: P0,
@@ -401,7 +193,7 @@ public class LambdaCallable6<P0, P1, P2, P3, P4, P5, R> @PublishedApi internal c
     p3: P3,
     p4: P4,
     p5: P5,
-  ) = LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3, p4, p5) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
@@ -409,86 +201,28 @@ public class LambdaCallable6<P0, P1, P2, P3, P4, P5, R> @PublishedApi internal c
     p3: P3,
     p4: P4,
     p5: P5,
-  ) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3, p4, p5) }
+  ): Callable1<R, P0>
 
   public fun bind(
     p2: P2,
     p3: P3,
     p4: P4,
     p5: P5,
-  ) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3, p4, p5) }
+  ): Callable2<R, P0, P1>
 
   public fun bind(
     p3: P3,
     p4: P4,
     p5: P5,
-  ) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3, p4, p5) }
-
-  public fun bind(p4: P4, p5: P5) =
-      LambdaCallable4(variantConverter, p0Type, p1Type, p2Type, p3Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3 -> function(p0, p1, p2, p3, p4, p5) }
+  ): Callable3<R, P0, P1, P2>
 
-  public fun bind(p5: P5) =
-      LambdaCallable5(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 -> function(p0, p1, p2, p3, p4, p5) }
+  public fun bind(p4: P4, p5: P5): Callable4<R, P0, P1, P2, P3>
 
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3, P4, P5> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      p4Class: Class<P4>,
-      p5Class: Class<P5>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-      ) -> R,
-    ) =
-        LambdaCallable6(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p4Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p5Class)]!!, null, function)
-  }
+  public fun bind(p5: P5): Callable5<R, P0, P1, P2, P3, P4>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    R> callable6(noinline onCancelCall: (() -> Unit)? = null, noinline function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-) -> R) =
-    LambdaCallable6(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable6(onCancelCall, this)
-
-public class LambdaCallable7<P0, P1, P2, P3, P4, P5, P6, R> @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  private val p3Type: VariantConverter,
-  private val p4Type: VariantConverter,
-  private val p5Type: VariantConverter,
-  p6Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable7<R, P0, P1, P2, P3, P4, P5, P6> : Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -496,13 +230,9 @@ public class LambdaCallable7<P0, P1, P2, P3, P4, P5, P6, R> @PublishedApi intern
     p4: P4,
     p5: P5,
     p6: P6,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type, p4Type,
-    p5Type, p6Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3, paramsArray[4] as P4, paramsArray[5] as P5, paramsArray[6] as P6)
+  ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -510,10 +240,17 @@ public class LambdaCallable7<P0, P1, P2, P3, P4, P5, P6, R> @PublishedApi intern
     p4: P4,
     p5: P5,
     p6: P6,
-  ): R = function(p0, p1, p2, p3, p4, p5, p6)
+  ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ): R = call(p0, p1, p2, p3, p4, p5, p6)
 
   public fun bind(
     p0: P0,
@@ -523,7 +260,7 @@ public class LambdaCallable7<P0, P1, P2, P3, P4, P5, P6, R> @PublishedApi intern
     p4: P4,
     p5: P5,
     p6: P6,
-  ) = LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3, p4, p5, p6) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
@@ -532,8 +269,7 @@ public class LambdaCallable7<P0, P1, P2, P3, P4, P5, P6, R> @PublishedApi intern
     p4: P4,
     p5: P5,
     p6: P6,
-  ) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3, p4, p5, p6) }
+  ): Callable1<R, P0>
 
   public fun bind(
     p2: P2,
@@ -541,91 +277,28 @@ public class LambdaCallable7<P0, P1, P2, P3, P4, P5, P6, R> @PublishedApi intern
     p4: P4,
     p5: P5,
     p6: P6,
-  ) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3, p4, p5, p6) }
+  ): Callable2<R, P0, P1>
 
   public fun bind(
     p3: P3,
     p4: P4,
     p5: P5,
     p6: P6,
-  ) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3, p4, p5, p6) }
+  ): Callable3<R, P0, P1, P2>
 
   public fun bind(
     p4: P4,
     p5: P5,
     p6: P6,
-  ) =
-      LambdaCallable4(variantConverter, p0Type, p1Type, p2Type, p3Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3 -> function(p0, p1, p2, p3, p4, p5, p6) }
-
-  public fun bind(p5: P5, p6: P6) =
-      LambdaCallable5(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 -> function(p0, p1, p2, p3, p4, p5, p6) }
+  ): Callable4<R, P0, P1, P2, P3>
 
-  public fun bind(p6: P6) =
-      LambdaCallable6(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 -> function(p0, p1, p2, p3, p4, p5, p6) }
+  public fun bind(p5: P5, p6: P6): Callable5<R, P0, P1, P2, P3, P4>
 
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3, P4, P5, P6> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      p4Class: Class<P4>,
-      p5Class: Class<P5>,
-      p6Class: Class<P6>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-      ) -> R,
-    ) =
-        LambdaCallable7(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p4Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p5Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p6Class)]!!, null, function)
-  }
+  public fun bind(p6: P6): Callable6<R, P0, P1, P2, P3, P4, P5>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified R> callable7(noinline onCancelCall: (() -> Unit)? = null, noinline function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-) -> R) =
-    LambdaCallable7(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable7(onCancelCall, this)
-
-public class LambdaCallable8<P0, P1, P2, P3, P4, P5, P6, P7, R> @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  private val p3Type: VariantConverter,
-  private val p4Type: VariantConverter,
-  private val p5Type: VariantConverter,
-  private val p6Type: VariantConverter,
-  p7Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable8<R, P0, P1, P2, P3, P4, P5, P6, P7> : Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -634,13 +307,9 @@ public class LambdaCallable8<P0, P1, P2, P3, P4, P5, P6, P7, R> @PublishedApi in
     p5: P5,
     p6: P6,
     p7: P7,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type, p4Type,
-    p5Type, p6Type, p7Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3, paramsArray[4] as P4, paramsArray[5] as P5, paramsArray[6] as P6, paramsArray[7] as P7)
+  ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -649,10 +318,18 @@ public class LambdaCallable8<P0, P1, P2, P3, P4, P5, P6, P7, R> @PublishedApi in
     p5: P5,
     p6: P6,
     p7: P7,
-  ): R = function(p0, p1, p2, p3, p4, p5, p6, p7)
+  ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, args[7] as P7)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ): R = call(p0, p1, p2, p3, p4, p5, p6, p7)
 
   public fun bind(
     p0: P0,
@@ -663,8 +340,7 @@ public class LambdaCallable8<P0, P1, P2, P3, P4, P5, P6, P7, R> @PublishedApi in
     p5: P5,
     p6: P6,
     p7: P7,
-  ) =
-      LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3, p4, p5, p6, p7) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
@@ -674,8 +350,7 @@ public class LambdaCallable8<P0, P1, P2, P3, P4, P5, P6, P7, R> @PublishedApi in
     p5: P5,
     p6: P6,
     p7: P7,
-  ) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3, p4, p5, p6, p7) }
+  ): Callable1<R, P0>
 
   public fun bind(
     p2: P2,
@@ -684,8 +359,7 @@ public class LambdaCallable8<P0, P1, P2, P3, P4, P5, P6, P7, R> @PublishedApi in
     p5: P5,
     p6: P6,
     p7: P7,
-  ) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3, p4, p5, p6, p7) }
+  ): Callable2<R, P0, P1>
 
   public fun bind(
     p3: P3,
@@ -693,98 +367,28 @@ public class LambdaCallable8<P0, P1, P2, P3, P4, P5, P6, P7, R> @PublishedApi in
     p5: P5,
     p6: P6,
     p7: P7,
-  ) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3, p4, p5, p6, p7) }
+  ): Callable3<R, P0, P1, P2>
 
   public fun bind(
     p4: P4,
     p5: P5,
     p6: P6,
     p7: P7,
-  ) =
-      LambdaCallable4(variantConverter, p0Type, p1Type, p2Type, p3Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3 -> function(p0, p1, p2, p3, p4, p5, p6, p7) }
+  ): Callable4<R, P0, P1, P2, P3>
 
   public fun bind(
     p5: P5,
     p6: P6,
     p7: P7,
-  ) =
-      LambdaCallable5(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 -> function(p0, p1, p2, p3, p4, p5, p6, p7) }
-
-  public fun bind(p6: P6, p7: P7) =
-      LambdaCallable6(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 -> function(p0, p1, p2, p3, p4, p5, p6, p7) }
+  ): Callable5<R, P0, P1, P2, P3, P4>
 
-  public fun bind(p7: P7) =
-      LambdaCallable7(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6 -> function(p0, p1, p2, p3, p4, p5, p6, p7) }
+  public fun bind(p6: P6, p7: P7): Callable6<R, P0, P1, P2, P3, P4, P5>
 
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3, P4, P5, P6, P7> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      p4Class: Class<P4>,
-      p5Class: Class<P5>,
-      p6Class: Class<P6>,
-      p7Class: Class<P7>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-      ) -> R,
-    ) =
-        LambdaCallable8(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p4Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p5Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p6Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p7Class)]!!, null, function)
-  }
+  public fun bind(p7: P7): Callable7<R, P0, P1, P2, P3, P4, P5, P6>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified R> callable8(noinline onCancelCall: (() -> Unit)? = null, noinline
-    function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-) -> R) =
-    LambdaCallable8(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable8(onCancelCall, this)
-
-public class LambdaCallable9<P0, P1, P2, P3, P4, P5, P6, P7, P8, R> @PublishedApi internal
-    constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  private val p3Type: VariantConverter,
-  private val p4Type: VariantConverter,
-  private val p5Type: VariantConverter,
-  private val p6Type: VariantConverter,
-  private val p7Type: VariantConverter,
-  p8Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8> : Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -794,13 +398,9 @@ public class LambdaCallable9<P0, P1, P2, P3, P4, P5, P6, P7, P8, R> @PublishedAp
     p6: P6,
     p7: P7,
     p8: P8,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type, p4Type,
-    p5Type, p6Type, p7Type, p8Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3, paramsArray[4] as P4, paramsArray[5] as P5, paramsArray[6] as P6, paramsArray[7] as P7, paramsArray[8] as P8)
+  ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -810,10 +410,19 @@ public class LambdaCallable9<P0, P1, P2, P3, P4, P5, P6, P7, P8, R> @PublishedAp
     p6: P6,
     p7: P7,
     p8: P8,
-  ): R = function(p0, p1, p2, p3, p4, p5, p6, p7, p8)
+  ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, args[7] as P7, args[8] as P8)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8)
 
   public fun bind(
     p0: P0,
@@ -825,8 +434,7 @@ public class LambdaCallable9<P0, P1, P2, P3, P4, P5, P6, P7, P8, R> @PublishedAp
     p6: P6,
     p7: P7,
     p8: P8,
-  ) =
-      LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
@@ -837,8 +445,7 @@ public class LambdaCallable9<P0, P1, P2, P3, P4, P5, P6, P7, P8, R> @PublishedAp
     p6: P6,
     p7: P7,
     p8: P8,
-  ) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8) }
+  ): Callable1<R, P0>
 
   public fun bind(
     p2: P2,
@@ -848,8 +455,7 @@ public class LambdaCallable9<P0, P1, P2, P3, P4, P5, P6, P7, P8, R> @PublishedAp
     p6: P6,
     p7: P7,
     p8: P8,
-  ) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8) }
+  ): Callable2<R, P0, P1>
 
   public fun bind(
     p3: P3,
@@ -858,8 +464,7 @@ public class LambdaCallable9<P0, P1, P2, P3, P4, P5, P6, P7, P8, R> @PublishedAp
     p6: P6,
     p7: P7,
     p8: P8,
-  ) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8) }
+  ): Callable3<R, P0, P1, P2>
 
   public fun bind(
     p4: P4,
@@ -867,103 +472,28 @@ public class LambdaCallable9<P0, P1, P2, P3, P4, P5, P6, P7, P8, R> @PublishedAp
     p6: P6,
     p7: P7,
     p8: P8,
-  ) =
-      LambdaCallable4(variantConverter, p0Type, p1Type, p2Type, p3Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8) }
+  ): Callable4<R, P0, P1, P2, P3>
 
   public fun bind(
     p5: P5,
     p6: P6,
     p7: P7,
     p8: P8,
-  ) =
-      LambdaCallable5(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8) }
+  ): Callable5<R, P0, P1, P2, P3, P4>
 
   public fun bind(
     p6: P6,
     p7: P7,
     p8: P8,
-  ) =
-      LambdaCallable6(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8) }
-
-  public fun bind(p7: P7, p8: P8) =
-      LambdaCallable7(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8) }
+  ): Callable6<R, P0, P1, P2, P3, P4, P5>
 
-  public fun bind(p8: P8) =
-      LambdaCallable8(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8) }
+  public fun bind(p7: P7, p8: P8): Callable7<R, P0, P1, P2, P3, P4, P5, P6>
 
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3, P4, P5, P6, P7, P8> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      p4Class: Class<P4>,
-      p5Class: Class<P5>,
-      p6Class: Class<P6>,
-      p7Class: Class<P7>,
-      p8Class: Class<P8>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-      ) -> R,
-    ) =
-        LambdaCallable9(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p4Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p5Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p6Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p7Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p8Class)]!!, null, function)
-  }
+  public fun bind(p8: P8): Callable8<R, P0, P1, P2, P3, P4, P5, P6, P7>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified R> callable9(noinline onCancelCall: (() -> Unit)? = null,
-    noinline function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-) -> R) =
-    LambdaCallable9(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable9(onCancelCall, this)
-
-public class LambdaCallable10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R> @PublishedApi internal
-    constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  private val p3Type: VariantConverter,
-  private val p4Type: VariantConverter,
-  private val p5Type: VariantConverter,
-  private val p6Type: VariantConverter,
-  private val p7Type: VariantConverter,
-  private val p8Type: VariantConverter,
-  p9Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> : Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -974,13 +504,9 @@ public class LambdaCallable10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R> @Publis
     p7: P7,
     p8: P8,
     p9: P9,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type, p4Type,
-    p5Type, p6Type, p7Type, p8Type, p9Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3, paramsArray[4] as P4, paramsArray[5] as P5, paramsArray[6] as P6, paramsArray[7] as P7, paramsArray[8] as P8, paramsArray[9] as P9)
+  ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -991,10 +517,20 @@ public class LambdaCallable10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R> @Publis
     p7: P7,
     p8: P8,
     p9: P9,
-  ): R = function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)
+  ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, args[7] as P7, args[8] as P8, args[9] as P9)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)
 
   public fun bind(
     p0: P0,
@@ -1007,8 +543,7 @@ public class LambdaCallable10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R> @Publis
     p7: P7,
     p8: P8,
     p9: P9,
-  ) =
-      LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
@@ -1020,8 +555,7 @@ public class LambdaCallable10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R> @Publis
     p7: P7,
     p8: P8,
     p9: P9,
-  ) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) }
+  ): Callable1<R, P0>
 
   public fun bind(
     p2: P2,
@@ -1032,8 +566,7 @@ public class LambdaCallable10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R> @Publis
     p7: P7,
     p8: P8,
     p9: P9,
-  ) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) }
+  ): Callable2<R, P0, P1>
 
   public fun bind(
     p3: P3,
@@ -1043,8 +576,7 @@ public class LambdaCallable10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R> @Publis
     p7: P7,
     p8: P8,
     p9: P9,
-  ) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) }
+  ): Callable3<R, P0, P1, P2>
 
   public fun bind(
     p4: P4,
@@ -1053,8 +585,7 @@ public class LambdaCallable10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R> @Publis
     p7: P7,
     p8: P8,
     p9: P9,
-  ) =
-      LambdaCallable4(variantConverter, p0Type, p1Type, p2Type, p3Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) }
+  ): Callable4<R, P0, P1, P2, P3>
 
   public fun bind(
     p5: P5,
@@ -1062,108 +593,28 @@ public class LambdaCallable10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R> @Publis
     p7: P7,
     p8: P8,
     p9: P9,
-  ) =
-      LambdaCallable5(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) }
+  ): Callable5<R, P0, P1, P2, P3, P4>
 
   public fun bind(
     p6: P6,
     p7: P7,
     p8: P8,
     p9: P9,
-  ) =
-      LambdaCallable6(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) }
+  ): Callable6<R, P0, P1, P2, P3, P4, P5>
 
   public fun bind(
     p7: P7,
     p8: P8,
     p9: P9,
-  ) =
-      LambdaCallable7(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) }
-
-  public fun bind(p8: P8, p9: P9) =
-      LambdaCallable8(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) }
+  ): Callable7<R, P0, P1, P2, P3, P4, P5, P6>
 
-  public fun bind(p9: P9) =
-      LambdaCallable9(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) }
+  public fun bind(p8: P8, p9: P9): Callable8<R, P0, P1, P2, P3, P4, P5, P6, P7>
 
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      p4Class: Class<P4>,
-      p5Class: Class<P5>,
-      p6Class: Class<P6>,
-      p7Class: Class<P7>,
-      p8Class: Class<P8>,
-      p9Class: Class<P9>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-      ) -> R,
-    ) =
-        LambdaCallable10(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p4Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p5Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p6Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p7Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p8Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p9Class)]!!, null, function)
-  }
+  public fun bind(p9: P9): Callable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified R> callable10(noinline
-    onCancelCall: (() -> Unit)? = null, noinline function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-) -> R) =
-    LambdaCallable10(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable10(onCancelCall, this)
-
-public class LambdaCallable11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> @PublishedApi internal
-    constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  private val p3Type: VariantConverter,
-  private val p4Type: VariantConverter,
-  private val p5Type: VariantConverter,
-  private val p6Type: VariantConverter,
-  private val p7Type: VariantConverter,
-  private val p8Type: VariantConverter,
-  private val p9Type: VariantConverter,
-  p10Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> : Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -1175,13 +626,9 @@ public class LambdaCallable11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> @P
     p8: P8,
     p9: P9,
     p10: P10,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type, p4Type,
-    p5Type, p6Type, p7Type, p8Type, p9Type, p10Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3, paramsArray[4] as P4, paramsArray[5] as P5, paramsArray[6] as P6, paramsArray[7] as P7, paramsArray[8] as P8, paramsArray[9] as P9, paramsArray[10] as P10)
+  ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -1193,10 +640,21 @@ public class LambdaCallable11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> @P
     p8: P8,
     p9: P9,
     p10: P10,
-  ): R = function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)
+  ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, args[7] as P7, args[8] as P8, args[9] as P9, args[10] as P10)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)
 
   public fun bind(
     p0: P0,
@@ -1210,8 +668,7 @@ public class LambdaCallable11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> @P
     p8: P8,
     p9: P9,
     p10: P10,
-  ) =
-      LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
@@ -1224,8 +681,7 @@ public class LambdaCallable11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> @P
     p8: P8,
     p9: P9,
     p10: P10,
-  ) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) }
+  ): Callable1<R, P0>
 
   public fun bind(
     p2: P2,
@@ -1237,8 +693,7 @@ public class LambdaCallable11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> @P
     p8: P8,
     p9: P9,
     p10: P10,
-  ) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) }
+  ): Callable2<R, P0, P1>
 
   public fun bind(
     p3: P3,
@@ -1249,8 +704,7 @@ public class LambdaCallable11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> @P
     p8: P8,
     p9: P9,
     p10: P10,
-  ) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) }
+  ): Callable3<R, P0, P1, P2>
 
   public fun bind(
     p4: P4,
@@ -1260,8 +714,7 @@ public class LambdaCallable11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> @P
     p8: P8,
     p9: P9,
     p10: P10,
-  ) =
-      LambdaCallable4(variantConverter, p0Type, p1Type, p2Type, p3Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) }
+  ): Callable4<R, P0, P1, P2, P3>
 
   public fun bind(
     p5: P5,
@@ -1270,8 +723,7 @@ public class LambdaCallable11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> @P
     p8: P8,
     p9: P9,
     p10: P10,
-  ) =
-      LambdaCallable5(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) }
+  ): Callable5<R, P0, P1, P2, P3, P4>
 
   public fun bind(
     p6: P6,
@@ -1279,113 +731,28 @@ public class LambdaCallable11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> @P
     p8: P8,
     p9: P9,
     p10: P10,
-  ) =
-      LambdaCallable6(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) }
+  ): Callable6<R, P0, P1, P2, P3, P4, P5>
 
   public fun bind(
     p7: P7,
     p8: P8,
     p9: P9,
     p10: P10,
-  ) =
-      LambdaCallable7(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) }
+  ): Callable7<R, P0, P1, P2, P3, P4, P5, P6>
 
   public fun bind(
     p8: P8,
     p9: P9,
     p10: P10,
-  ) =
-      LambdaCallable8(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) }
-
-  public fun bind(p9: P9, p10: P10) =
-      LambdaCallable9(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) }
+  ): Callable8<R, P0, P1, P2, P3, P4, P5, P6, P7>
 
-  public fun bind(p10: P10) =
-      LambdaCallable10(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) }
+  public fun bind(p9: P9, p10: P10): Callable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>
 
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      p4Class: Class<P4>,
-      p5Class: Class<P5>,
-      p6Class: Class<P6>,
-      p7Class: Class<P7>,
-      p8Class: Class<P8>,
-      p9Class: Class<P9>,
-      p10Class: Class<P10>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-      ) -> R,
-    ) =
-        LambdaCallable11(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p4Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p5Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p6Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p7Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p8Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p9Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p10Class)]!!, null, function)
-  }
+  public fun bind(p10: P10): Callable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified P10, reified R> callable11(noinline
-    onCancelCall: (() -> Unit)? = null, noinline function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-  p10: P10,
-) -> R) =
-    LambdaCallable11(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified P10, reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-  p10: P10,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable11(onCancelCall, this)
-
-public class LambdaCallable12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, R> @PublishedApi
-    internal constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  private val p3Type: VariantConverter,
-  private val p4Type: VariantConverter,
-  private val p5Type: VariantConverter,
-  private val p6Type: VariantConverter,
-  private val p7Type: VariantConverter,
-  private val p8Type: VariantConverter,
-  private val p9Type: VariantConverter,
-  private val p10Type: VariantConverter,
-  p11Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> : Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -1398,13 +765,9 @@ public class LambdaCallable12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p9: P9,
     p10: P10,
     p11: P11,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type, p4Type,
-    p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3, paramsArray[4] as P4, paramsArray[5] as P5, paramsArray[6] as P6, paramsArray[7] as P7, paramsArray[8] as P8, paramsArray[9] as P9, paramsArray[10] as P10, paramsArray[11] as P11)
+  ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -1417,10 +780,22 @@ public class LambdaCallable12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p9: P9,
     p10: P10,
     p11: P11,
-  ): R = function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)
+  ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, args[7] as P7, args[8] as P8, args[9] as P9, args[10] as P10, args[11] as P11)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)
 
   public fun bind(
     p0: P0,
@@ -1435,8 +810,7 @@ public class LambdaCallable12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p9: P9,
     p10: P10,
     p11: P11,
-  ) =
-      LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
@@ -1450,8 +824,7 @@ public class LambdaCallable12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p9: P9,
     p10: P10,
     p11: P11,
-  ) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) }
+  ): Callable1<R, P0>
 
   public fun bind(
     p2: P2,
@@ -1464,8 +837,7 @@ public class LambdaCallable12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p9: P9,
     p10: P10,
     p11: P11,
-  ) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) }
+  ): Callable2<R, P0, P1>
 
   public fun bind(
     p3: P3,
@@ -1477,8 +849,7 @@ public class LambdaCallable12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p9: P9,
     p10: P10,
     p11: P11,
-  ) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) }
+  ): Callable3<R, P0, P1, P2>
 
   public fun bind(
     p4: P4,
@@ -1489,8 +860,7 @@ public class LambdaCallable12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p9: P9,
     p10: P10,
     p11: P11,
-  ) =
-      LambdaCallable4(variantConverter, p0Type, p1Type, p2Type, p3Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) }
+  ): Callable4<R, P0, P1, P2, P3>
 
   public fun bind(
     p5: P5,
@@ -1500,8 +870,7 @@ public class LambdaCallable12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p9: P9,
     p10: P10,
     p11: P11,
-  ) =
-      LambdaCallable5(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) }
+  ): Callable5<R, P0, P1, P2, P3, P4>
 
   public fun bind(
     p6: P6,
@@ -1510,8 +879,7 @@ public class LambdaCallable12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p9: P9,
     p10: P10,
     p11: P11,
-  ) =
-      LambdaCallable6(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) }
+  ): Callable6<R, P0, P1, P2, P3, P4, P5>
 
   public fun bind(
     p7: P7,
@@ -1519,118 +887,28 @@ public class LambdaCallable12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p9: P9,
     p10: P10,
     p11: P11,
-  ) =
-      LambdaCallable7(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) }
+  ): Callable7<R, P0, P1, P2, P3, P4, P5, P6>
 
   public fun bind(
     p8: P8,
     p9: P9,
     p10: P10,
     p11: P11,
-  ) =
-      LambdaCallable8(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) }
+  ): Callable8<R, P0, P1, P2, P3, P4, P5, P6, P7>
 
   public fun bind(
     p9: P9,
     p10: P10,
     p11: P11,
-  ) =
-      LambdaCallable9(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) }
-
-  public fun bind(p10: P10, p11: P11) =
-      LambdaCallable10(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) }
+  ): Callable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>
 
-  public fun bind(p11: P11) =
-      LambdaCallable11(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) }
+  public fun bind(p10: P10, p11: P11): Callable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>
 
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      p4Class: Class<P4>,
-      p5Class: Class<P5>,
-      p6Class: Class<P6>,
-      p7Class: Class<P7>,
-      p8Class: Class<P8>,
-      p9Class: Class<P9>,
-      p10Class: Class<P10>,
-      p11Class: Class<P11>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-      ) -> R,
-    ) =
-        LambdaCallable12(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p4Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p5Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p6Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p7Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p8Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p9Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p10Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p11Class)]!!, null, function)
-  }
+  public fun bind(p11: P11): Callable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified R> callable12(noinline
-    onCancelCall: (() -> Unit)? = null, noinline function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-  p10: P10,
-  p11: P11,
-) -> R) =
-    LambdaCallable12(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-  p10: P10,
-  p11: P11,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable12(onCancelCall, this)
-
-public class LambdaCallable13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, R>
-    @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  private val p3Type: VariantConverter,
-  private val p4Type: VariantConverter,
-  private val p5Type: VariantConverter,
-  private val p6Type: VariantConverter,
-  private val p7Type: VariantConverter,
-  private val p8Type: VariantConverter,
-  private val p9Type: VariantConverter,
-  private val p10Type: VariantConverter,
-  private val p11Type: VariantConverter,
-  p12Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> : Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -1644,13 +922,9 @@ public class LambdaCallable13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p10: P10,
     p11: P11,
     p12: P12,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type, p4Type,
-    p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, p12Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3, paramsArray[4] as P4, paramsArray[5] as P5, paramsArray[6] as P6, paramsArray[7] as P7, paramsArray[8] as P8, paramsArray[9] as P9, paramsArray[10] as P10, paramsArray[11] as P11, paramsArray[12] as P12)
+  ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -1664,10 +938,23 @@ public class LambdaCallable13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p10: P10,
     p11: P11,
     p12: P12,
-  ): R = function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)
+  ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, args[7] as P7, args[8] as P8, args[9] as P9, args[10] as P10, args[11] as P11, args[12] as P12)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)
 
   public fun bind(
     p0: P0,
@@ -1683,8 +970,7 @@ public class LambdaCallable13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p10: P10,
     p11: P11,
     p12: P12,
-  ) =
-      LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
@@ -1699,8 +985,7 @@ public class LambdaCallable13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p10: P10,
     p11: P11,
     p12: P12,
-  ) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
+  ): Callable1<R, P0>
 
   public fun bind(
     p2: P2,
@@ -1714,8 +999,7 @@ public class LambdaCallable13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p10: P10,
     p11: P11,
     p12: P12,
-  ) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
+  ): Callable2<R, P0, P1>
 
   public fun bind(
     p3: P3,
@@ -1728,8 +1012,7 @@ public class LambdaCallable13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p10: P10,
     p11: P11,
     p12: P12,
-  ) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
+  ): Callable3<R, P0, P1, P2>
 
   public fun bind(
     p4: P4,
@@ -1741,8 +1024,7 @@ public class LambdaCallable13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p10: P10,
     p11: P11,
     p12: P12,
-  ) =
-      LambdaCallable4(variantConverter, p0Type, p1Type, p2Type, p3Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
+  ): Callable4<R, P0, P1, P2, P3>
 
   public fun bind(
     p5: P5,
@@ -1753,8 +1035,7 @@ public class LambdaCallable13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p10: P10,
     p11: P11,
     p12: P12,
-  ) =
-      LambdaCallable5(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
+  ): Callable5<R, P0, P1, P2, P3, P4>
 
   public fun bind(
     p6: P6,
@@ -1764,8 +1045,7 @@ public class LambdaCallable13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p10: P10,
     p11: P11,
     p12: P12,
-  ) =
-      LambdaCallable6(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
+  ): Callable6<R, P0, P1, P2, P3, P4, P5>
 
   public fun bind(
     p7: P7,
@@ -1774,8 +1054,7 @@ public class LambdaCallable13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p10: P10,
     p11: P11,
     p12: P12,
-  ) =
-      LambdaCallable7(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
+  ): Callable7<R, P0, P1, P2, P3, P4, P5, P6>
 
   public fun bind(
     p8: P8,
@@ -1783,123 +1062,29 @@ public class LambdaCallable13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p10: P10,
     p11: P11,
     p12: P12,
-  ) =
-      LambdaCallable8(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
+  ): Callable8<R, P0, P1, P2, P3, P4, P5, P6, P7>
 
   public fun bind(
     p9: P9,
     p10: P10,
     p11: P11,
     p12: P12,
-  ) =
-      LambdaCallable9(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
+  ): Callable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>
 
   public fun bind(
     p10: P10,
     p11: P11,
     p12: P12,
-  ) =
-      LambdaCallable10(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
-
-  public fun bind(p11: P11, p12: P12) =
-      LambdaCallable11(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
-
-  public fun bind(p12: P12) =
-      LambdaCallable12(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) }
-
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      p4Class: Class<P4>,
-      p5Class: Class<P5>,
-      p6Class: Class<P6>,
-      p7Class: Class<P7>,
-      p8Class: Class<P8>,
-      p9Class: Class<P9>,
-      p10Class: Class<P10>,
-      p11Class: Class<P11>,
-      p12Class: Class<P12>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-        p12: P12,
-      ) -> R,
-    ) =
-        LambdaCallable13(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p4Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p5Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p6Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p7Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p8Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p9Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p10Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p11Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p12Class)]!!, null, function)
-  }
+  ): Callable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>
+
+  public fun bind(p11: P11, p12: P12): Callable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>
+
+  public fun bind(p12: P12): Callable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified R>
-    callable13(noinline onCancelCall: (() -> Unit)? = null, noinline function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-  p10: P10,
-  p11: P11,
-  p12: P12,
-) -> R) =
-    LambdaCallable13(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-  p10: P10,
-  p11: P11,
-  p12: P12,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable13(onCancelCall, this)
-
-public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, R>
-    @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  private val p3Type: VariantConverter,
-  private val p4Type: VariantConverter,
-  private val p5Type: VariantConverter,
-  private val p6Type: VariantConverter,
-  private val p7Type: VariantConverter,
-  private val p8Type: VariantConverter,
-  private val p9Type: VariantConverter,
-  private val p10Type: VariantConverter,
-  private val p11Type: VariantConverter,
-  private val p12Type: VariantConverter,
-  p13Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> :
+    Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -1914,13 +1099,9 @@ public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p11: P11,
     p12: P12,
     p13: P13,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type, p4Type,
-    p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, p12Type, p13Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3, paramsArray[4] as P4, paramsArray[5] as P5, paramsArray[6] as P6, paramsArray[7] as P7, paramsArray[8] as P8, paramsArray[9] as P9, paramsArray[10] as P10, paramsArray[11] as P11, paramsArray[12] as P12, paramsArray[13] as P13)
+  ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -1935,10 +1116,24 @@ public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p11: P11,
     p12: P12,
     p13: P13,
-  ): R = function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)
+  ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, args[7] as P7, args[8] as P8, args[9] as P9, args[10] as P10, args[11] as P11, args[12] as P12, args[13] as P13)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)
 
   public fun bind(
     p0: P0,
@@ -1955,8 +1150,7 @@ public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p11: P11,
     p12: P12,
     p13: P13,
-  ) =
-      LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
@@ -1972,8 +1166,7 @@ public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p11: P11,
     p12: P12,
     p13: P13,
-  ) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
+  ): Callable1<R, P0>
 
   public fun bind(
     p2: P2,
@@ -1988,8 +1181,7 @@ public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p11: P11,
     p12: P12,
     p13: P13,
-  ) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
+  ): Callable2<R, P0, P1>
 
   public fun bind(
     p3: P3,
@@ -2003,8 +1195,7 @@ public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p11: P11,
     p12: P12,
     p13: P13,
-  ) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
+  ): Callable3<R, P0, P1, P2>
 
   public fun bind(
     p4: P4,
@@ -2017,8 +1208,7 @@ public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p11: P11,
     p12: P12,
     p13: P13,
-  ) =
-      LambdaCallable4(variantConverter, p0Type, p1Type, p2Type, p3Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
+  ): Callable4<R, P0, P1, P2, P3>
 
   public fun bind(
     p5: P5,
@@ -2030,8 +1220,7 @@ public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p11: P11,
     p12: P12,
     p13: P13,
-  ) =
-      LambdaCallable5(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
+  ): Callable5<R, P0, P1, P2, P3, P4>
 
   public fun bind(
     p6: P6,
@@ -2042,8 +1231,7 @@ public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p11: P11,
     p12: P12,
     p13: P13,
-  ) =
-      LambdaCallable6(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
+  ): Callable6<R, P0, P1, P2, P3, P4, P5>
 
   public fun bind(
     p7: P7,
@@ -2053,8 +1241,7 @@ public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p11: P11,
     p12: P12,
     p13: P13,
-  ) =
-      LambdaCallable7(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
+  ): Callable7<R, P0, P1, P2, P3, P4, P5, P6>
 
   public fun bind(
     p8: P8,
@@ -2063,8 +1250,7 @@ public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p11: P11,
     p12: P12,
     p13: P13,
-  ) =
-      LambdaCallable8(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
+  ): Callable8<R, P0, P1, P2, P3, P4, P5, P6, P7>
 
   public fun bind(
     p9: P9,
@@ -2072,129 +1258,30 @@ public class LambdaCallable14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p11: P11,
     p12: P12,
     p13: P13,
-  ) =
-      LambdaCallable9(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
+  ): Callable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>
 
   public fun bind(
     p10: P10,
     p11: P11,
     p12: P12,
     p13: P13,
-  ) =
-      LambdaCallable10(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
+  ): Callable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>
 
   public fun bind(
     p11: P11,
     p12: P12,
     p13: P13,
-  ) =
-      LambdaCallable11(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
-
-  public fun bind(p12: P12, p13: P13) =
-      LambdaCallable12(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
-
-  public fun bind(p13: P13) =
-      LambdaCallable13(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, p12Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) }
-
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      p4Class: Class<P4>,
-      p5Class: Class<P5>,
-      p6Class: Class<P6>,
-      p7Class: Class<P7>,
-      p8Class: Class<P8>,
-      p9Class: Class<P9>,
-      p10Class: Class<P10>,
-      p11Class: Class<P11>,
-      p12Class: Class<P12>,
-      p13Class: Class<P13>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-        p12: P12,
-        p13: P13,
-      ) -> R,
-    ) =
-        LambdaCallable14(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p4Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p5Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p6Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p7Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p8Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p9Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p10Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p11Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p12Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p13Class)]!!, null, function)
-  }
+  ): Callable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>
+
+  public fun bind(p12: P12, p13: P13):
+      Callable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>
+
+  public fun bind(p13: P13): Callable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
-    reified R> callable14(noinline onCancelCall: (() -> Unit)? = null, noinline function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-  p10: P10,
-  p11: P11,
-  p12: P12,
-  p13: P13,
-) -> R) =
-    LambdaCallable14(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
-    reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-  p10: P10,
-  p11: P11,
-  p12: P12,
-  p13: P13,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable14(onCancelCall, this)
-
-public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, R>
-    @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  private val p3Type: VariantConverter,
-  private val p4Type: VariantConverter,
-  private val p5Type: VariantConverter,
-  private val p6Type: VariantConverter,
-  private val p7Type: VariantConverter,
-  private val p8Type: VariantConverter,
-  private val p9Type: VariantConverter,
-  private val p10Type: VariantConverter,
-  private val p11Type: VariantConverter,
-  private val p12Type: VariantConverter,
-  private val p13Type: VariantConverter,
-  p14Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable15<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> :
+    Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -2210,13 +1297,9 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type, p4Type,
-    p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, p12Type, p13Type, p14Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3, paramsArray[4] as P4, paramsArray[5] as P5, paramsArray[6] as P6, paramsArray[7] as P7, paramsArray[8] as P8, paramsArray[9] as P9, paramsArray[10] as P10, paramsArray[11] as P11, paramsArray[12] as P12, paramsArray[13] as P13, paramsArray[14] as P14)
+  ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -2232,10 +1315,25 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ): R = function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)
+  ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, args[7] as P7, args[8] as P8, args[9] as P9, args[10] as P10, args[11] as P11, args[12] as P12, args[13] as P13, args[14] as P14)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)
 
   public fun bind(
     p0: P0,
@@ -2253,8 +1351,7 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
@@ -2271,8 +1368,7 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
+  ): Callable1<R, P0>
 
   public fun bind(
     p2: P2,
@@ -2288,8 +1384,7 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
+  ): Callable2<R, P0, P1>
 
   public fun bind(
     p3: P3,
@@ -2304,8 +1399,7 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
+  ): Callable3<R, P0, P1, P2>
 
   public fun bind(
     p4: P4,
@@ -2319,8 +1413,7 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable4(variantConverter, p0Type, p1Type, p2Type, p3Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
+  ): Callable4<R, P0, P1, P2, P3>
 
   public fun bind(
     p5: P5,
@@ -2333,8 +1426,7 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable5(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
+  ): Callable5<R, P0, P1, P2, P3, P4>
 
   public fun bind(
     p6: P6,
@@ -2346,8 +1438,7 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable6(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
+  ): Callable6<R, P0, P1, P2, P3, P4, P5>
 
   public fun bind(
     p7: P7,
@@ -2358,8 +1449,7 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable7(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
+  ): Callable7<R, P0, P1, P2, P3, P4, P5, P6>
 
   public fun bind(
     p8: P8,
@@ -2369,8 +1459,7 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable8(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
+  ): Callable8<R, P0, P1, P2, P3, P4, P5, P6, P7>
 
   public fun bind(
     p9: P9,
@@ -2379,8 +1468,7 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable9(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
+  ): Callable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>
 
   public fun bind(
     p10: P10,
@@ -2388,135 +1476,31 @@ public class LambdaCallable15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable10(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
+  ): Callable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>
 
   public fun bind(
     p11: P11,
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable11(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
+  ): Callable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>
 
   public fun bind(
     p12: P12,
     p13: P13,
     p14: P14,
-  ) =
-      LambdaCallable12(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
-
-  public fun bind(p13: P13, p14: P14) =
-      LambdaCallable13(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, p12Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
-
-  public fun bind(p14: P14) =
-      LambdaCallable14(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, p12Type, p13Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) }
-
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      p4Class: Class<P4>,
-      p5Class: Class<P5>,
-      p6Class: Class<P6>,
-      p7Class: Class<P7>,
-      p8Class: Class<P8>,
-      p9Class: Class<P9>,
-      p10Class: Class<P10>,
-      p11Class: Class<P11>,
-      p12Class: Class<P12>,
-      p13Class: Class<P13>,
-      p14Class: Class<P14>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-        p12: P12,
-        p13: P13,
-        p14: P14,
-      ) -> R,
-    ) =
-        LambdaCallable15(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p4Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p5Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p6Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p7Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p8Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p9Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p10Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p11Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p12Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p13Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p14Class)]!!, null, function)
-  }
+  ): Callable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>
+
+  public fun bind(p13: P13, p14: P14):
+      Callable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>
+
+  public fun bind(p14: P14):
+      Callable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>
 }
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
-    reified P14, reified R> callable15(noinline onCancelCall: (() -> Unit)? = null, noinline
-    function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-  p10: P10,
-  p11: P11,
-  p12: P12,
-  p13: P13,
-  p14: P14,
-) -> R) =
-    LambdaCallable15(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!, variantMapper[P14::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
-    reified P14, reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-  p10: P10,
-  p11: P11,
-  p12: P12,
-  p13: P13,
-  p14: P14,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable15(onCancelCall, this)
-
-public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15,
-    R> @PublishedApi internal constructor(
-  variantConverter: VariantConverter,
-  private val p0Type: VariantConverter,
-  private val p1Type: VariantConverter,
-  private val p2Type: VariantConverter,
-  private val p3Type: VariantConverter,
-  private val p4Type: VariantConverter,
-  private val p5Type: VariantConverter,
-  private val p6Type: VariantConverter,
-  private val p7Type: VariantConverter,
-  private val p8Type: VariantConverter,
-  private val p9Type: VariantConverter,
-  private val p10Type: VariantConverter,
-  private val p11Type: VariantConverter,
-  private val p12Type: VariantConverter,
-  private val p13Type: VariantConverter,
-  private val p14Type: VariantConverter,
-  p15Type: VariantConverter,
-  onCancelCall: (() -> Unit)? = null,
-  private val function: (
+public interface Callable16<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>
+    : Callable {
+  public fun call(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -2533,13 +1517,9 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) -> R,
-) : LambdaCallable<R>(variantConverter, onCancelCall, p0Type, p1Type, p2Type, p3Type, p4Type,
-    p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, p12Type, p13Type, p14Type, p15Type) {
-  public override fun invokeKt(): R =
-      function(paramsArray[0] as P0, paramsArray[1] as P1, paramsArray[2] as P2, paramsArray[3] as P3, paramsArray[4] as P4, paramsArray[5] as P5, paramsArray[6] as P6, paramsArray[7] as P7, paramsArray[8] as P8, paramsArray[9] as P9, paramsArray[10] as P10, paramsArray[11] as P11, paramsArray[12] as P12, paramsArray[13] as P13, paramsArray[14] as P14, paramsArray[15] as P15)
+  ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) as R
 
-  public operator fun invoke(
+  public fun callDeferred(
     p0: P0,
     p1: P1,
     p2: P2,
@@ -2556,10 +1536,26 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ): R = function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)
+  ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)
 
-  public override fun call(vararg args: Any?): Any? =
-      function(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, args[7] as P7, args[8] as P8, args[9] as P9, args[10] as P10, args[11] as P11, args[12] as P12, args[13] as P13, args[14] as P14, args[15] as P15)
+  public operator fun invoke(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)
 
   public fun bind(
     p0: P0,
@@ -2578,8 +1574,7 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable0(variantConverter, onCancelCall) {  -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable0<R>
 
   public fun bind(
     p1: P1,
@@ -2597,8 +1592,7 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable1(variantConverter, p0Type, onCancelCall) { p0: P0 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable1<R, P0>
 
   public fun bind(
     p2: P2,
@@ -2615,8 +1609,7 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable2(variantConverter, p0Type, p1Type, onCancelCall) { p0: P0, p1: P1 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable2<R, P0, P1>
 
   public fun bind(
     p3: P3,
@@ -2632,8 +1625,7 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable3(variantConverter, p0Type, p1Type, p2Type, onCancelCall) { p0: P0, p1: P1, p2: P2 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable3<R, P0, P1, P2>
 
   public fun bind(
     p4: P4,
@@ -2648,8 +1640,7 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable4(variantConverter, p0Type, p1Type, p2Type, p3Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable4<R, P0, P1, P2, P3>
 
   public fun bind(
     p5: P5,
@@ -2663,8 +1654,7 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable5(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable5<R, P0, P1, P2, P3, P4>
 
   public fun bind(
     p6: P6,
@@ -2677,8 +1667,7 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable6(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable6<R, P0, P1, P2, P3, P4, P5>
 
   public fun bind(
     p7: P7,
@@ -2690,8 +1679,7 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable7(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable7<R, P0, P1, P2, P3, P4, P5, P6>
 
   public fun bind(
     p8: P8,
@@ -2702,8 +1690,7 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable8(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable8<R, P0, P1, P2, P3, P4, P5, P6, P7>
 
   public fun bind(
     p9: P9,
@@ -2713,8 +1700,7 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable9(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>
 
   public fun bind(
     p10: P10,
@@ -2723,8 +1709,7 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable10(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>
 
   public fun bind(
     p11: P11,
@@ -2732,114 +1717,24 @@ public class LambdaCallable16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable11(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>
 
   public fun bind(
     p12: P12,
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable12(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
+  ): Callable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>
 
   public fun bind(
     p13: P13,
     p14: P14,
     p15: P15,
-  ) =
-      LambdaCallable13(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, p12Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
-
-  public fun bind(p14: P14, p15: P15) =
-      LambdaCallable14(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, p12Type, p13Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
-
-  public fun bind(p15: P15) =
-      LambdaCallable15(variantConverter, p0Type, p1Type, p2Type, p3Type, p4Type, p5Type, p6Type, p7Type, p8Type, p9Type, p10Type, p11Type, p12Type, p13Type, p14Type, onCancelCall) { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14 -> function(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) }
-
-  public companion object {
-    @JvmStatic
-    @JvmName("create")
-    public fun <R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> javaCreate(
-      returnClass: Class<R>,
-      p0Class: Class<P0>,
-      p1Class: Class<P1>,
-      p2Class: Class<P2>,
-      p3Class: Class<P3>,
-      p4Class: Class<P4>,
-      p5Class: Class<P5>,
-      p6Class: Class<P6>,
-      p7Class: Class<P7>,
-      p8Class: Class<P8>,
-      p9Class: Class<P9>,
-      p10Class: Class<P10>,
-      p11Class: Class<P11>,
-      p12Class: Class<P12>,
-      p13Class: Class<P13>,
-      p14Class: Class<P14>,
-      p15Class: Class<P15>,
-      function: (
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-        p12: P12,
-        p13: P13,
-        p14: P14,
-        p15: P15,
-      ) -> R,
-    ) =
-        LambdaCallable16(variantMapper.getOrDefault(Reflection.getOrCreateKotlinClass(returnClass), NIL), variantMapper[Reflection.getOrCreateKotlinClass(p0Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p1Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p2Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p3Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p4Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p5Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p6Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p7Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p8Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p9Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p10Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p11Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p12Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p13Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p14Class)]!!, variantMapper[Reflection.getOrCreateKotlinClass(p15Class)]!!, null, function)
-  }
-}
+  ): Callable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
-    reified P14, reified P15, reified R> callable16(noinline onCancelCall: (() -> Unit)? = null,
-    noinline function: (
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-  p10: P10,
-  p11: P11,
-  p12: P12,
-  p13: P13,
-  p14: P14,
-  p15: P15,
-) -> R) =
-    LambdaCallable16(variantMapper.getOrDefault(R::class, NIL), variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!, variantMapper[P14::class]!!, variantMapper[P15::class]!!, onCancelCall, function)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
-    reified P14, reified P15, reified R> ((
-  p0: P0,
-  p1: P1,
-  p2: P2,
-  p3: P3,
-  p4: P4,
-  p5: P5,
-  p6: P6,
-  p7: P7,
-  p8: P8,
-  p9: P9,
-  p10: P10,
-  p11: P11,
-  p12: P12,
-  p13: P13,
-  p14: P14,
-  p15: P15,
-) -> R).asCallable(noinline onCancelCall: (() -> Unit)? = null) = callable16(onCancelCall, this)
+  public fun bind(p14: P14, p15: P15):
+      Callable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>
+
+  public fun bind(p15: P15):
+      Callable15<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>
+}
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt
new file mode 100644
index 000000000..fe1d8de2a
--- /dev/null
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt
@@ -0,0 +1,1793 @@
+@file:Suppress(
+  "PackageDirectoryMismatch", "UNCHECKED_CAST",
+  "unused",
+)
+
+package godot.core
+
+import godot.core.VariantParser.NIL
+import kotlin.Any
+import kotlin.Array
+import kotlin.PublishedApi
+import kotlin.Suppress
+
+public class LambdaCallable0<R> @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs), Callable0<R>
+
+public inline fun <reified R> callable0(noinline function: () -> R) =
+    LambdaCallable0<R>(LambdaContainer0<R>(variantMapper.getOrDefault(R::class, NIL), arrayOf(), function))
+
+public inline fun <reified R> (() -> R).asCallable() = callable0(this)
+
+public class LambdaCallable1<R, P0> @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs), Callable1<R, P0> {
+  public override fun bind(p0: P0) = LambdaCallable0<R>(container, arrayOf<Any?>(p0, *boundArgs))
+}
+
+public inline fun <reified R, reified P0> callable1(noinline function: (p0: P0) -> R) =
+    LambdaCallable1<R, P0>(LambdaContainer1<R, P0>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!), function))
+
+public inline fun <reified R, reified P0> ((p0: P0) -> R).asCallable() = callable1(this)
+
+public class LambdaCallable2<R, P0, P1> @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs), Callable2<R, P0, P1> {
+  public override fun bind(p0: P0, p1: P1) = LambdaCallable0<R>(container, arrayOf<Any?>(p0, p1,
+      *boundArgs))
+
+  public override fun bind(p1: P1) = LambdaCallable1<R, P0>(container, arrayOf<Any?>(p1,
+      *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1> callable2(noinline function: (p0: P0,
+    p1: P1) -> R) =
+    LambdaCallable2<R, P0, P1>(LambdaContainer2<R, P0, P1>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1> ((p0: P0, p1: P1) -> R).asCallable() =
+    callable2(this)
+
+public class LambdaCallable3<R, P0, P1, P2> @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs), Callable3<R, P0, P1, P2> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+  ) = LambdaCallable0<R>(container, arrayOf<Any?>(p0, p1, p2, *boundArgs))
+
+  public override fun bind(p1: P1, p2: P2) = LambdaCallable1<R, P0>(container, arrayOf<Any?>(p1, p2,
+      *boundArgs))
+
+  public override fun bind(p2: P2) = LambdaCallable2<R, P0, P1>(container, arrayOf<Any?>(p2,
+      *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2> callable3(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+) -> R) =
+    LambdaCallable3<R, P0, P1, P2>(LambdaContainer3<R, P0, P1, P2>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+) -> R).asCallable() = callable3(this)
+
+public class LambdaCallable4<R, P0, P1, P2, P3> @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs), Callable4<R, P0, P1, P2, P3> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+  ) = LambdaCallable0<R>(container, arrayOf<Any?>(p0, p1, p2, p3, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+  ) = LambdaCallable1<R, P0>(container, arrayOf<Any?>(p1, p2, p3, *boundArgs))
+
+  public override fun bind(p2: P2, p3: P3) = LambdaCallable2<R, P0, P1>(container,
+      arrayOf<Any?>(p2, p3, *boundArgs))
+
+  public override fun bind(p3: P3) = LambdaCallable3<R, P0, P1, P2>(container, arrayOf<Any?>(p3,
+      *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3> callable4(noinline
+    function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+) -> R) =
+    LambdaCallable4<R, P0, P1, P2, P3>(LambdaContainer4<R, P0, P1, P2, P3>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+) -> R).asCallable() = callable4(this)
+
+public class LambdaCallable5<R, P0, P1, P2, P3, P4> @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs), Callable5<R, P0, P1, P2, P3, P4> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+  ) = LambdaCallable0<R>(container, arrayOf<Any?>(p0, p1, p2, p3, p4, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+  ) = LambdaCallable1<R, P0>(container, arrayOf<Any?>(p1, p2, p3, p4, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+  ) = LambdaCallable2<R, P0, P1>(container, arrayOf<Any?>(p2, p3, p4, *boundArgs))
+
+  public override fun bind(p3: P3, p4: P4) = LambdaCallable3<R, P0, P1, P2>(container,
+      arrayOf<Any?>(p3, p4, *boundArgs))
+
+  public override fun bind(p4: P4) = LambdaCallable4<R, P0, P1, P2, P3>(container, arrayOf<Any?>(p4,
+      *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4>
+    callable5(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+) -> R) =
+    LambdaCallable5<R, P0, P1, P2, P3, P4>(LambdaContainer5<R, P0, P1, P2, P3, P4>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+) -> R).asCallable() = callable5(this)
+
+public class LambdaCallable6<R, P0, P1, P2, P3, P4, P5> @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs), Callable6<R, P0, P1, P2, P3, P4, P5> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+  ) = LambdaCallable0<R>(container, arrayOf<Any?>(p0, p1, p2, p3, p4, p5, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+  ) = LambdaCallable1<R, P0>(container, arrayOf<Any?>(p1, p2, p3, p4, p5, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+  ) = LambdaCallable2<R, P0, P1>(container, arrayOf<Any?>(p2, p3, p4, p5, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+  ) = LambdaCallable3<R, P0, P1, P2>(container, arrayOf<Any?>(p3, p4, p5, *boundArgs))
+
+  public override fun bind(p4: P4, p5: P5) = LambdaCallable4<R, P0, P1, P2, P3>(container,
+      arrayOf<Any?>(p4, p5, *boundArgs))
+
+  public override fun bind(p5: P5) = LambdaCallable5<R, P0, P1, P2, P3, P4>(container,
+      arrayOf<Any?>(p5, *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5> callable6(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+) -> R) =
+    LambdaCallable6<R, P0, P1, P2, P3, P4, P5>(LambdaContainer6<R, P0, P1, P2, P3, P4, P5>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+) -> R).asCallable() = callable6(this)
+
+public class LambdaCallable7<R, P0, P1, P2, P3, P4, P5, P6> @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs), Callable7<R, P0, P1, P2, P3, P4, P5, P6> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ) = LambdaCallable0<R>(container, arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ) = LambdaCallable1<R, P0>(container, arrayOf<Any?>(p1, p2, p3, p4, p5, p6, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ) = LambdaCallable2<R, P0, P1>(container, arrayOf<Any?>(p2, p3, p4, p5, p6, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ) = LambdaCallable3<R, P0, P1, P2>(container, arrayOf<Any?>(p3, p4, p5, p6, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ) = LambdaCallable4<R, P0, P1, P2, P3>(container, arrayOf<Any?>(p4, p5, p6, *boundArgs))
+
+  public override fun bind(p5: P5, p6: P6) = LambdaCallable5<R, P0, P1, P2, P3, P4>(container,
+      arrayOf<Any?>(p5, p6, *boundArgs))
+
+  public override fun bind(p6: P6) = LambdaCallable6<R, P0, P1, P2, P3, P4, P5>(container,
+      arrayOf<Any?>(p6, *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6> callable7(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+) -> R) =
+    LambdaCallable7<R, P0, P1, P2, P3, P4, P5, P6>(LambdaContainer7<R, P0, P1, P2, P3, P4, P5, P6>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+) -> R).asCallable() = callable7(this)
+
+public class LambdaCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7> @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs), Callable8<R, P0, P1, P2, P3, P4, P5, P6, P7> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) = LambdaCallable0<R>(container, arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) = LambdaCallable1<R, P0>(container, arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) = LambdaCallable2<R, P0, P1>(container, arrayOf<Any?>(p2, p3, p4, p5, p6, p7, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) = LambdaCallable3<R, P0, P1, P2>(container, arrayOf<Any?>(p3, p4, p5, p6, p7, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) = LambdaCallable4<R, P0, P1, P2, P3>(container, arrayOf<Any?>(p4, p5, p6, p7, *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) = LambdaCallable5<R, P0, P1, P2, P3, P4>(container, arrayOf<Any?>(p5, p6, p7, *boundArgs))
+
+  public override fun bind(p6: P6, p7: P7) = LambdaCallable6<R, P0, P1, P2, P3, P4, P5>(container,
+      arrayOf<Any?>(p6, p7, *boundArgs))
+
+  public override fun bind(p7: P7) = LambdaCallable7<R, P0, P1, P2, P3, P4, P5, P6>(container,
+      arrayOf<Any?>(p7, *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7> callable8(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+) -> R) =
+    LambdaCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(LambdaContainer8<R, P0, P1, P2, P3, P4, P5, P6, P7>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+) -> R).asCallable() = callable8(this)
+
+public class LambdaCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8> @PublishedApi internal
+    constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs), Callable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = LambdaCallable0<R>(container, arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = LambdaCallable1<R, P0>(container, arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = LambdaCallable2<R, P0, P1>(container, arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = LambdaCallable3<R, P0, P1, P2>(container, arrayOf<Any?>(p3, p4, p5, p6, p7, p8, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = LambdaCallable4<R, P0, P1, P2, P3>(container, arrayOf<Any?>(p4, p5, p6, p7, p8, *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = LambdaCallable5<R, P0, P1, P2, P3, P4>(container, arrayOf<Any?>(p5, p6, p7, p8, *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = LambdaCallable6<R, P0, P1, P2, P3, P4, P5>(container, arrayOf<Any?>(p6, p7, p8, *boundArgs))
+
+  public override fun bind(p7: P7, p8: P8) =
+      LambdaCallable7<R, P0, P1, P2, P3, P4, P5, P6>(container, arrayOf<Any?>(p7, p8, *boundArgs))
+
+  public override fun bind(p8: P8) = LambdaCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(container,
+      arrayOf<Any?>(p8, *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8> callable9(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+) -> R) =
+    LambdaCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(LambdaContainer9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+) -> R).asCallable() = callable9(this)
+
+public class LambdaCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> @PublishedApi internal
+    constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs), Callable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = LambdaCallable0<R>(container, arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = LambdaCallable1<R, P0>(container, arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = LambdaCallable2<R, P0, P1>(container, arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = LambdaCallable3<R, P0, P1, P2>(container, arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = LambdaCallable4<R, P0, P1, P2, P3>(container, arrayOf<Any?>(p4, p5, p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = LambdaCallable5<R, P0, P1, P2, P3, P4>(container, arrayOf<Any?>(p5, p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = LambdaCallable6<R, P0, P1, P2, P3, P4, P5>(container, arrayOf<Any?>(p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = LambdaCallable7<R, P0, P1, P2, P3, P4, P5, P6>(container, arrayOf<Any?>(p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(p8: P8, p9: P9) =
+      LambdaCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(container, arrayOf<Any?>(p8, p9,
+      *boundArgs))
+
+  public override fun bind(p9: P9) =
+      LambdaCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(container, arrayOf<Any?>(p9,
+      *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9> callable10(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+) -> R) =
+    LambdaCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(LambdaContainer10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+) -> R).asCallable() = callable10(this)
+
+public class LambdaCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> @PublishedApi internal
+    constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs),
+    Callable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = LambdaCallable0<R>(container, arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
+      *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = LambdaCallable1<R, P0>(container, arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
+      *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = LambdaCallable2<R, P0, P1>(container, arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9, p10,
+      *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = LambdaCallable3<R, P0, P1, P2>(container, arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9, p10,
+      *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = LambdaCallable4<R, P0, P1, P2, P3>(container, arrayOf<Any?>(p4, p5, p6, p7, p8, p9, p10,
+      *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = LambdaCallable5<R, P0, P1, P2, P3, P4>(container, arrayOf<Any?>(p5, p6, p7, p8, p9, p10,
+      *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = LambdaCallable6<R, P0, P1, P2, P3, P4, P5>(container, arrayOf<Any?>(p6, p7, p8, p9, p10,
+      *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = LambdaCallable7<R, P0, P1, P2, P3, P4, P5, P6>(container, arrayOf<Any?>(p7, p8, p9, p10,
+      *boundArgs))
+
+  public override fun bind(
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = LambdaCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(container, arrayOf<Any?>(p8, p9, p10,
+      *boundArgs))
+
+  public override fun bind(p9: P9, p10: P10) =
+      LambdaCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(container, arrayOf<Any?>(p9, p10,
+      *boundArgs))
+
+  public override fun bind(p10: P10) =
+      LambdaCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(container, arrayOf<Any?>(p10,
+      *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9, reified P10> callable11(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+) -> R) =
+    LambdaCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(LambdaContainer11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9, reified P10> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+) -> R).asCallable() = callable11(this)
+
+public class LambdaCallable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> @PublishedApi
+    internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs),
+    Callable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = LambdaCallable0<R>(container, arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
+      *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = LambdaCallable1<R, P0>(container, arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
+      *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = LambdaCallable2<R, P0, P1>(container, arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
+      *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = LambdaCallable3<R, P0, P1, P2>(container, arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9, p10, p11,
+      *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = LambdaCallable4<R, P0, P1, P2, P3>(container, arrayOf<Any?>(p4, p5, p6, p7, p8, p9, p10, p11,
+      *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = LambdaCallable5<R, P0, P1, P2, P3, P4>(container, arrayOf<Any?>(p5, p6, p7, p8, p9, p10, p11,
+      *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = LambdaCallable6<R, P0, P1, P2, P3, P4, P5>(container, arrayOf<Any?>(p6, p7, p8, p9, p10, p11,
+      *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = LambdaCallable7<R, P0, P1, P2, P3, P4, P5, P6>(container, arrayOf<Any?>(p7, p8, p9, p10, p11,
+      *boundArgs))
+
+  public override fun bind(
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = LambdaCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(container, arrayOf<Any?>(p8, p9, p10, p11,
+      *boundArgs))
+
+  public override fun bind(
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = LambdaCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(container, arrayOf<Any?>(p9, p10, p11,
+      *boundArgs))
+
+  public override fun bind(p10: P10, p11: P11) =
+      LambdaCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(container, arrayOf<Any?>(p10, p11,
+      *boundArgs))
+
+  public override fun bind(p11: P11) =
+      LambdaCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(container, arrayOf<Any?>(p11,
+      *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9, reified P10, reified P11>
+    callable12(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+) -> R) =
+    LambdaCallable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(LambdaContainer12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9, reified P10, reified P11> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+) -> R).asCallable() = callable12(this)
+
+public class LambdaCallable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>
+    @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs),
+    Callable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = LambdaCallable0<R>(container,
+      arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = LambdaCallable1<R, P0>(container,
+      arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = LambdaCallable2<R, P0, P1>(container,
+      arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = LambdaCallable3<R, P0, P1, P2>(container,
+      arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = LambdaCallable4<R, P0, P1, P2, P3>(container,
+      arrayOf<Any?>(p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = LambdaCallable5<R, P0, P1, P2, P3, P4>(container,
+      arrayOf<Any?>(p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = LambdaCallable6<R, P0, P1, P2, P3, P4, P5>(container,
+      arrayOf<Any?>(p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = LambdaCallable7<R, P0, P1, P2, P3, P4, P5, P6>(container,
+      arrayOf<Any?>(p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = LambdaCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(container,
+      arrayOf<Any?>(p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = LambdaCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(container,
+      arrayOf<Any?>(p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = LambdaCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(container,
+      arrayOf<Any?>(p10, p11, p12, *boundArgs))
+
+  public override fun bind(p11: P11, p12: P12) =
+      LambdaCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(container,
+      arrayOf<Any?>(p11, p12, *boundArgs))
+
+  public override fun bind(p12: P12) =
+      LambdaCallable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(container,
+      arrayOf<Any?>(p12, *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12>
+    callable13(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+) -> R) =
+    LambdaCallable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(LambdaContainer13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+) -> R).asCallable() = callable13(this)
+
+public class LambdaCallable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>
+    @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs),
+    Callable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = LambdaCallable0<R>(container,
+      arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = LambdaCallable1<R, P0>(container,
+      arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = LambdaCallable2<R, P0, P1>(container,
+      arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = LambdaCallable3<R, P0, P1, P2>(container,
+      arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = LambdaCallable4<R, P0, P1, P2, P3>(container,
+      arrayOf<Any?>(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = LambdaCallable5<R, P0, P1, P2, P3, P4>(container,
+      arrayOf<Any?>(p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = LambdaCallable6<R, P0, P1, P2, P3, P4, P5>(container,
+      arrayOf<Any?>(p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = LambdaCallable7<R, P0, P1, P2, P3, P4, P5, P6>(container,
+      arrayOf<Any?>(p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = LambdaCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(container,
+      arrayOf<Any?>(p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = LambdaCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(container,
+      arrayOf<Any?>(p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = LambdaCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(container,
+      arrayOf<Any?>(p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = LambdaCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(container,
+      arrayOf<Any?>(p11, p12, p13, *boundArgs))
+
+  public override fun bind(p12: P12, p13: P13) =
+      LambdaCallable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(container,
+      arrayOf<Any?>(p12, p13, *boundArgs))
+
+  public override fun bind(p13: P13) =
+      LambdaCallable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(container,
+      arrayOf<Any?>(p13, *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12,
+    reified P13> callable14(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+) -> R) =
+    LambdaCallable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(LambdaContainer14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12,
+    reified P13> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+) -> R).asCallable() = callable14(this)
+
+public class LambdaCallable15<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>
+    @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs),
+    Callable15<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable0<R>(container,
+      arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable1<R, P0>(container,
+      arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable2<R, P0, P1>(container,
+      arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable3<R, P0, P1, P2>(container,
+      arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable4<R, P0, P1, P2, P3>(container,
+      arrayOf<Any?>(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable5<R, P0, P1, P2, P3, P4>(container,
+      arrayOf<Any?>(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable6<R, P0, P1, P2, P3, P4, P5>(container,
+      arrayOf<Any?>(p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable7<R, P0, P1, P2, P3, P4, P5, P6>(container,
+      arrayOf<Any?>(p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(container,
+      arrayOf<Any?>(p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(container,
+      arrayOf<Any?>(p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(container,
+      arrayOf<Any?>(p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(container,
+      arrayOf<Any?>(p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = LambdaCallable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(container,
+      arrayOf<Any?>(p12, p13, p14, *boundArgs))
+
+  public override fun bind(p13: P13, p14: P14) =
+      LambdaCallable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(container,
+      arrayOf<Any?>(p13, p14, *boundArgs))
+
+  public override fun bind(p14: P14) =
+      LambdaCallable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(container,
+      arrayOf<Any?>(p14, *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12,
+    reified P13, reified P14> callable15(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+  p14: P14,
+) -> R) =
+    LambdaCallable15<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(LambdaContainer15<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!, variantMapper[P14::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12,
+    reified P13, reified P14> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+  p14: P14,
+) -> R).asCallable() = callable15(this)
+
+public class LambdaCallable16<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14,
+    P15> @PublishedApi internal constructor(
+  container: LambdaContainer<R>,
+  boundArgs: Array<Any?> = emptyArray(),
+) : LambdaCallable<R>(container, boundArgs),
+    Callable16<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable0<R>(container,
+      arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15,
+      *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable1<R, P0>(container,
+      arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable2<R, P0, P1>(container,
+      arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable3<R, P0, P1, P2>(container,
+      arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable4<R, P0, P1, P2, P3>(container,
+      arrayOf<Any?>(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable5<R, P0, P1, P2, P3, P4>(container,
+      arrayOf<Any?>(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable6<R, P0, P1, P2, P3, P4, P5>(container,
+      arrayOf<Any?>(p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable7<R, P0, P1, P2, P3, P4, P5, P6>(container,
+      arrayOf<Any?>(p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(container,
+      arrayOf<Any?>(p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(container,
+      arrayOf<Any?>(p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(container,
+      arrayOf<Any?>(p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(container,
+      arrayOf<Any?>(p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(container,
+      arrayOf<Any?>(p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = LambdaCallable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(container,
+      arrayOf<Any?>(p13, p14, p15, *boundArgs))
+
+  public override fun bind(p14: P14, p15: P15) =
+      LambdaCallable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(container,
+      arrayOf<Any?>(p14, p15, *boundArgs))
+
+  public override fun bind(p15: P15) =
+      LambdaCallable15<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(container,
+      arrayOf<Any?>(p15, *boundArgs))
+}
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12,
+    reified P13, reified P14, reified P15> callable16(noinline function: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+  p14: P14,
+  p15: P15,
+) -> R) =
+    LambdaCallable16<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>(LambdaContainer16<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!, variantMapper[P14::class]!!, variantMapper[P15::class]!!), function))
+
+public inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified
+    P5, reified P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12,
+    reified P13, reified P14, reified P15> ((
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+  p14: P14,
+  p15: P15,
+) -> R).asCallable() = callable16(this)
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaContainers.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaContainers.kt
new file mode 100644
index 000000000..e1bb94a0c
--- /dev/null
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaContainers.kt
@@ -0,0 +1,445 @@
+@file:Suppress(
+  "PackageDirectoryMismatch", "UNCHECKED_CAST",
+  "unused",
+)
+
+package godot.core
+
+import godot.common.interop.VariantConverter
+import kotlin.Any
+import kotlin.Array
+import kotlin.Suppress
+
+public class LambdaContainer0<R>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: () -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R =
+      (function as? () -> R)?.invoke()?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer1<R, P0>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (p0: P0) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R =
+      (function as? (p0: Any?) -> R)?.invoke(args[0])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer2<R, P0, P1>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (p0: P0, p1: P1) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (p0: Any?,
+      p1: Any?) -> R)?.invoke(args[0], args[1])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer3<R, P0, P1, P2>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer4<R, P0, P1, P2, P3>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer5<R, P0, P1, P2, P3, P4>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+    p4: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3], args[4])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer6<R, P0, P1, P2, P3, P4, P5>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+    p4: Any?,
+    p5: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3], args[4], args[5])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer7<R, P0, P1, P2, P3, P4, P5, P6>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+    p4: Any?,
+    p5: Any?,
+    p6: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3], args[4], args[5], args[6])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer8<R, P0, P1, P2, P3, P4, P5, P6, P7>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+    p4: Any?,
+    p5: Any?,
+    p6: Any?,
+    p7: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+    p4: Any?,
+    p5: Any?,
+    p6: Any?,
+    p7: Any?,
+    p8: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+    p4: Any?,
+    p5: Any?,
+    p6: Any?,
+    p7: Any?,
+    p8: Any?,
+    p9: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+    p4: Any?,
+    p5: Any?,
+    p6: Any?,
+    p7: Any?,
+    p8: Any?,
+    p9: Any?,
+    p10: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+    p4: Any?,
+    p5: Any?,
+    p6: Any?,
+    p7: Any?,
+    p8: Any?,
+    p9: Any?,
+    p10: Any?,
+    p11: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+    p4: Any?,
+    p5: Any?,
+    p6: Any?,
+    p7: Any?,
+    p8: Any?,
+    p9: Any?,
+    p10: Any?,
+    p11: Any?,
+    p12: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11], args[12])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+    p4: Any?,
+    p5: Any?,
+    p6: Any?,
+    p7: Any?,
+    p8: Any?,
+    p9: Any?,
+    p10: Any?,
+    p11: Any?,
+    p12: Any?,
+    p13: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11], args[12], args[13])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer15<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+    p4: Any?,
+    p5: Any?,
+    p6: Any?,
+    p7: Any?,
+    p8: Any?,
+    p9: Any?,
+    p10: Any?,
+    p11: Any?,
+    p12: Any?,
+    p13: Any?,
+    p14: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11], args[12], args[13], args[14])?: throw InvalidJvmLambdaException()
+}
+
+public class LambdaContainer16<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14,
+    P15>(
+  returnConverter: VariantConverter,
+  typeConverters: Array<VariantConverter>,
+  function: (
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) -> R,
+) : LambdaContainer<R>(returnConverter, typeConverters, function) {
+  public override fun invokeUnsafe(vararg args: Any?): R = (function as? (
+    p0: Any?,
+    p1: Any?,
+    p2: Any?,
+    p3: Any?,
+    p4: Any?,
+    p5: Any?,
+    p6: Any?,
+    p7: Any?,
+    p8: Any?,
+    p9: Any?,
+    p10: Any?,
+    p11: Any?,
+    p12: Any?,
+    p13: Any?,
+    p14: Any?,
+    p15: Any?,
+  ) -> R)?.invoke(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11], args[12], args[13], args[14], args[15])?: throw InvalidJvmLambdaException()
+}
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/MethodCallables.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/MethodCallables.kt
new file mode 100644
index 000000000..d19795e06
--- /dev/null
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/MethodCallables.kt
@@ -0,0 +1,1614 @@
+@file:Suppress(
+  "PackageDirectoryMismatch", "UNCHECKED_CAST",
+  "unused",
+)
+
+package godot.core
+
+import godot.api.Object
+import kotlin.Any
+import kotlin.Array
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.reflect.KCallable
+
+public class MethodCallable0<R> @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs), Callable0<R>
+
+public fun <T : Object, R> T.callable0(callable: T.() -> R) =
+    MethodCallable0<R>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable1<R, P0> @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs), Callable1<R, P0> {
+  public override fun bind(p0: P0) = MethodCallable0<R>(target, methodName, arrayOf<Any?>(p0,
+      *boundArgs))
+}
+
+public fun <T : Object, R, P0> T.callable1(callable: T.(p0: P0) -> R) =
+    MethodCallable1<R, P0>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable2<R, P0, P1> @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs), Callable2<R, P0, P1> {
+  public override fun bind(p0: P0, p1: P1) = MethodCallable0<R>(target, methodName,
+      arrayOf<Any?>(p0, p1, *boundArgs))
+
+  public override fun bind(p1: P1) = MethodCallable1<R, P0>(target, methodName, arrayOf<Any?>(p1,
+      *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1> T.callable2(callable: T.(p0: P0, p1: P1) -> R) =
+    MethodCallable2<R, P0, P1>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable3<R, P0, P1, P2> @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs), Callable3<R, P0, P1, P2> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+  ) = MethodCallable0<R>(target, methodName, arrayOf<Any?>(p0, p1, p2, *boundArgs))
+
+  public override fun bind(p1: P1, p2: P2) = MethodCallable1<R, P0>(target, methodName,
+      arrayOf<Any?>(p1, p2, *boundArgs))
+
+  public override fun bind(p2: P2) = MethodCallable2<R, P0, P1>(target, methodName,
+      arrayOf<Any?>(p2, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2> T.callable3(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+) -> R) = MethodCallable3<R, P0, P1, P2>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable4<R, P0, P1, P2, P3> @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs), Callable4<R, P0, P1, P2, P3> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+  ) = MethodCallable0<R>(target, methodName, arrayOf<Any?>(p0, p1, p2, p3, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+  ) = MethodCallable1<R, P0>(target, methodName, arrayOf<Any?>(p1, p2, p3, *boundArgs))
+
+  public override fun bind(p2: P2, p3: P3) = MethodCallable2<R, P0, P1>(target, methodName,
+      arrayOf<Any?>(p2, p3, *boundArgs))
+
+  public override fun bind(p3: P3) = MethodCallable3<R, P0, P1, P2>(target, methodName,
+      arrayOf<Any?>(p3, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3> T.callable4(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+) -> R) = MethodCallable4<R, P0, P1, P2, P3>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable5<R, P0, P1, P2, P3, P4> @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs), Callable5<R, P0, P1, P2, P3, P4> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+  ) = MethodCallable0<R>(target, methodName, arrayOf<Any?>(p0, p1, p2, p3, p4, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+  ) = MethodCallable1<R, P0>(target, methodName, arrayOf<Any?>(p1, p2, p3, p4, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+  ) = MethodCallable2<R, P0, P1>(target, methodName, arrayOf<Any?>(p2, p3, p4, *boundArgs))
+
+  public override fun bind(p3: P3, p4: P4) = MethodCallable3<R, P0, P1, P2>(target, methodName,
+      arrayOf<Any?>(p3, p4, *boundArgs))
+
+  public override fun bind(p4: P4) = MethodCallable4<R, P0, P1, P2, P3>(target, methodName,
+      arrayOf<Any?>(p4, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3, P4> T.callable5(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+) -> R) =
+    MethodCallable5<R, P0, P1, P2, P3, P4>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable6<R, P0, P1, P2, P3, P4, P5> @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs), Callable6<R, P0, P1, P2, P3, P4, P5> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+  ) = MethodCallable0<R>(target, methodName, arrayOf<Any?>(p0, p1, p2, p3, p4, p5, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+  ) = MethodCallable1<R, P0>(target, methodName, arrayOf<Any?>(p1, p2, p3, p4, p5, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+  ) = MethodCallable2<R, P0, P1>(target, methodName, arrayOf<Any?>(p2, p3, p4, p5, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+  ) = MethodCallable3<R, P0, P1, P2>(target, methodName, arrayOf<Any?>(p3, p4, p5, *boundArgs))
+
+  public override fun bind(p4: P4, p5: P5) = MethodCallable4<R, P0, P1, P2, P3>(target, methodName,
+      arrayOf<Any?>(p4, p5, *boundArgs))
+
+  public override fun bind(p5: P5) = MethodCallable5<R, P0, P1, P2, P3, P4>(target, methodName,
+      arrayOf<Any?>(p5, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3, P4, P5> T.callable6(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+) -> R) =
+    MethodCallable6<R, P0, P1, P2, P3, P4, P5>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable7<R, P0, P1, P2, P3, P4, P5, P6> @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs), Callable7<R, P0, P1, P2, P3, P4, P5, P6> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ) = MethodCallable0<R>(target, methodName, arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ) = MethodCallable1<R, P0>(target, methodName, arrayOf<Any?>(p1, p2, p3, p4, p5, p6, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ) = MethodCallable2<R, P0, P1>(target, methodName, arrayOf<Any?>(p2, p3, p4, p5, p6, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ) = MethodCallable3<R, P0, P1, P2>(target, methodName, arrayOf<Any?>(p3, p4, p5, p6, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ) = MethodCallable4<R, P0, P1, P2, P3>(target, methodName, arrayOf<Any?>(p4, p5, p6, *boundArgs))
+
+  public override fun bind(p5: P5, p6: P6) = MethodCallable5<R, P0, P1, P2, P3, P4>(target,
+      methodName, arrayOf<Any?>(p5, p6, *boundArgs))
+
+  public override fun bind(p6: P6) = MethodCallable6<R, P0, P1, P2, P3, P4, P5>(target, methodName,
+      arrayOf<Any?>(p6, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3, P4, P5, P6> T.callable7(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+) -> R) =
+    MethodCallable7<R, P0, P1, P2, P3, P4, P5, P6>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7> @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs), Callable8<R, P0, P1, P2, P3, P4, P5, P6, P7> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) = MethodCallable0<R>(target, methodName, arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7,
+      *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) = MethodCallable1<R, P0>(target, methodName, arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7,
+      *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) = MethodCallable2<R, P0, P1>(target, methodName, arrayOf<Any?>(p2, p3, p4, p5, p6, p7,
+      *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) = MethodCallable3<R, P0, P1, P2>(target, methodName, arrayOf<Any?>(p3, p4, p5, p6, p7,
+      *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) = MethodCallable4<R, P0, P1, P2, P3>(target, methodName, arrayOf<Any?>(p4, p5, p6, p7,
+      *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) = MethodCallable5<R, P0, P1, P2, P3, P4>(target, methodName, arrayOf<Any?>(p5, p6, p7,
+      *boundArgs))
+
+  public override fun bind(p6: P6, p7: P7) = MethodCallable6<R, P0, P1, P2, P3, P4, P5>(target,
+      methodName, arrayOf<Any?>(p6, p7, *boundArgs))
+
+  public override fun bind(p7: P7) = MethodCallable7<R, P0, P1, P2, P3, P4, P5, P6>(target,
+      methodName, arrayOf<Any?>(p7, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3, P4, P5, P6, P7> T.callable8(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+) -> R) =
+    MethodCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8> @PublishedApi internal
+    constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs), Callable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>
+    {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = MethodCallable0<R>(target, methodName, arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8,
+      *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = MethodCallable1<R, P0>(target, methodName, arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8,
+      *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = MethodCallable2<R, P0, P1>(target, methodName, arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8,
+      *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = MethodCallable3<R, P0, P1, P2>(target, methodName, arrayOf<Any?>(p3, p4, p5, p6, p7, p8,
+      *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = MethodCallable4<R, P0, P1, P2, P3>(target, methodName, arrayOf<Any?>(p4, p5, p6, p7, p8,
+      *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = MethodCallable5<R, P0, P1, P2, P3, P4>(target, methodName, arrayOf<Any?>(p5, p6, p7, p8,
+      *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) = MethodCallable6<R, P0, P1, P2, P3, P4, P5>(target, methodName, arrayOf<Any?>(p6, p7, p8,
+      *boundArgs))
+
+  public override fun bind(p7: P7, p8: P8) = MethodCallable7<R, P0, P1, P2, P3, P4, P5, P6>(target,
+      methodName, arrayOf<Any?>(p7, p8, *boundArgs))
+
+  public override fun bind(p8: P8) = MethodCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(target,
+      methodName, arrayOf<Any?>(p8, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3, P4, P5, P6, P7, P8> T.callable9(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+) -> R) =
+    MethodCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> @PublishedApi internal
+    constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs),
+    Callable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = MethodCallable0<R>(target, methodName, arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = MethodCallable1<R, P0>(target, methodName, arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = MethodCallable2<R, P0, P1>(target, methodName, arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = MethodCallable3<R, P0, P1, P2>(target, methodName, arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = MethodCallable4<R, P0, P1, P2, P3>(target, methodName, arrayOf<Any?>(p4, p5, p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = MethodCallable5<R, P0, P1, P2, P3, P4>(target, methodName, arrayOf<Any?>(p5, p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = MethodCallable6<R, P0, P1, P2, P3, P4, P5>(target, methodName, arrayOf<Any?>(p6, p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) = MethodCallable7<R, P0, P1, P2, P3, P4, P5, P6>(target, methodName, arrayOf<Any?>(p7, p8, p9,
+      *boundArgs))
+
+  public override fun bind(p8: P8, p9: P9) =
+      MethodCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(target, methodName, arrayOf<Any?>(p8, p9,
+      *boundArgs))
+
+  public override fun bind(p9: P9) = MethodCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(target,
+      methodName, arrayOf<Any?>(p9, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> T.callable10(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+) -> R) =
+    MethodCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> @PublishedApi internal
+    constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs),
+    Callable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = MethodCallable0<R>(target, methodName,
+      arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = MethodCallable1<R, P0>(target, methodName,
+      arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = MethodCallable2<R, P0, P1>(target, methodName,
+      arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9, p10, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = MethodCallable3<R, P0, P1, P2>(target, methodName,
+      arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9, p10, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = MethodCallable4<R, P0, P1, P2, P3>(target, methodName,
+      arrayOf<Any?>(p4, p5, p6, p7, p8, p9, p10, *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = MethodCallable5<R, P0, P1, P2, P3, P4>(target, methodName,
+      arrayOf<Any?>(p5, p6, p7, p8, p9, p10, *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = MethodCallable6<R, P0, P1, P2, P3, P4, P5>(target, methodName,
+      arrayOf<Any?>(p6, p7, p8, p9, p10, *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = MethodCallable7<R, P0, P1, P2, P3, P4, P5, P6>(target, methodName,
+      arrayOf<Any?>(p7, p8, p9, p10, *boundArgs))
+
+  public override fun bind(
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) = MethodCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(target, methodName,
+      arrayOf<Any?>(p8, p9, p10, *boundArgs))
+
+  public override fun bind(p9: P9, p10: P10) =
+      MethodCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(target, methodName,
+      arrayOf<Any?>(p9, p10, *boundArgs))
+
+  public override fun bind(p10: P10) =
+      MethodCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(target, methodName,
+      arrayOf<Any?>(p10, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> T.callable11(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+) -> R) =
+    MethodCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> @PublishedApi
+    internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs),
+    Callable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = MethodCallable0<R>(target, methodName,
+      arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = MethodCallable1<R, P0>(target, methodName,
+      arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = MethodCallable2<R, P0, P1>(target, methodName,
+      arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = MethodCallable3<R, P0, P1, P2>(target, methodName,
+      arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = MethodCallable4<R, P0, P1, P2, P3>(target, methodName,
+      arrayOf<Any?>(p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = MethodCallable5<R, P0, P1, P2, P3, P4>(target, methodName,
+      arrayOf<Any?>(p5, p6, p7, p8, p9, p10, p11, *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = MethodCallable6<R, P0, P1, P2, P3, P4, P5>(target, methodName,
+      arrayOf<Any?>(p6, p7, p8, p9, p10, p11, *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = MethodCallable7<R, P0, P1, P2, P3, P4, P5, P6>(target, methodName,
+      arrayOf<Any?>(p7, p8, p9, p10, p11, *boundArgs))
+
+  public override fun bind(
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = MethodCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(target, methodName,
+      arrayOf<Any?>(p8, p9, p10, p11, *boundArgs))
+
+  public override fun bind(
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) = MethodCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(target, methodName,
+      arrayOf<Any?>(p9, p10, p11, *boundArgs))
+
+  public override fun bind(p10: P10, p11: P11) =
+      MethodCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(target, methodName,
+      arrayOf<Any?>(p10, p11, *boundArgs))
+
+  public override fun bind(p11: P11) =
+      MethodCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(target, methodName,
+      arrayOf<Any?>(p11, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>
+    T.callable12(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+) -> R) =
+    MethodCallable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>
+    @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs),
+    Callable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = MethodCallable0<R>(target, methodName,
+      arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = MethodCallable1<R, P0>(target, methodName,
+      arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = MethodCallable2<R, P0, P1>(target, methodName,
+      arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = MethodCallable3<R, P0, P1, P2>(target, methodName,
+      arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = MethodCallable4<R, P0, P1, P2, P3>(target, methodName,
+      arrayOf<Any?>(p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = MethodCallable5<R, P0, P1, P2, P3, P4>(target, methodName,
+      arrayOf<Any?>(p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = MethodCallable6<R, P0, P1, P2, P3, P4, P5>(target, methodName,
+      arrayOf<Any?>(p6, p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = MethodCallable7<R, P0, P1, P2, P3, P4, P5, P6>(target, methodName,
+      arrayOf<Any?>(p7, p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = MethodCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(target, methodName,
+      arrayOf<Any?>(p8, p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = MethodCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(target, methodName,
+      arrayOf<Any?>(p9, p10, p11, p12, *boundArgs))
+
+  public override fun bind(
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) = MethodCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(target, methodName,
+      arrayOf<Any?>(p10, p11, p12, *boundArgs))
+
+  public override fun bind(p11: P11, p12: P12) =
+      MethodCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(target, methodName,
+      arrayOf<Any?>(p11, p12, *boundArgs))
+
+  public override fun bind(p12: P12) =
+      MethodCallable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(target, methodName,
+      arrayOf<Any?>(p12, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>
+    T.callable13(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+) -> R) =
+    MethodCallable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>
+    @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs),
+    Callable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = MethodCallable0<R>(target, methodName,
+      arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = MethodCallable1<R, P0>(target, methodName,
+      arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = MethodCallable2<R, P0, P1>(target, methodName,
+      arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = MethodCallable3<R, P0, P1, P2>(target, methodName,
+      arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = MethodCallable4<R, P0, P1, P2, P3>(target, methodName,
+      arrayOf<Any?>(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = MethodCallable5<R, P0, P1, P2, P3, P4>(target, methodName,
+      arrayOf<Any?>(p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = MethodCallable6<R, P0, P1, P2, P3, P4, P5>(target, methodName,
+      arrayOf<Any?>(p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = MethodCallable7<R, P0, P1, P2, P3, P4, P5, P6>(target, methodName,
+      arrayOf<Any?>(p7, p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = MethodCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(target, methodName,
+      arrayOf<Any?>(p8, p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = MethodCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(target, methodName,
+      arrayOf<Any?>(p9, p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = MethodCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(target, methodName,
+      arrayOf<Any?>(p10, p11, p12, p13, *boundArgs))
+
+  public override fun bind(
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) = MethodCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(target, methodName,
+      arrayOf<Any?>(p11, p12, p13, *boundArgs))
+
+  public override fun bind(p12: P12, p13: P13) =
+      MethodCallable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(target, methodName,
+      arrayOf<Any?>(p12, p13, *boundArgs))
+
+  public override fun bind(p13: P13) =
+      MethodCallable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(target, methodName,
+      arrayOf<Any?>(p13, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>
+    T.callable14(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+) -> R) =
+    MethodCallable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable15<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>
+    @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs),
+    Callable15<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable0<R>(target, methodName,
+      arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable1<R, P0>(target, methodName,
+      arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable2<R, P0, P1>(target, methodName,
+      arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable3<R, P0, P1, P2>(target, methodName,
+      arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable4<R, P0, P1, P2, P3>(target, methodName,
+      arrayOf<Any?>(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable5<R, P0, P1, P2, P3, P4>(target, methodName,
+      arrayOf<Any?>(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable6<R, P0, P1, P2, P3, P4, P5>(target, methodName,
+      arrayOf<Any?>(p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable7<R, P0, P1, P2, P3, P4, P5, P6>(target, methodName,
+      arrayOf<Any?>(p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(target, methodName,
+      arrayOf<Any?>(p8, p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(target, methodName,
+      arrayOf<Any?>(p9, p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(target, methodName,
+      arrayOf<Any?>(p10, p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(target, methodName,
+      arrayOf<Any?>(p11, p12, p13, p14, *boundArgs))
+
+  public override fun bind(
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) = MethodCallable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(target, methodName,
+      arrayOf<Any?>(p12, p13, p14, *boundArgs))
+
+  public override fun bind(p13: P13, p14: P14) =
+      MethodCallable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(target, methodName,
+      arrayOf<Any?>(p13, p14, *boundArgs))
+
+  public override fun bind(p14: P14) =
+      MethodCallable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(target,
+      methodName, arrayOf<Any?>(p14, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>
+    T.callable15(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+  p14: P14,
+) -> R) =
+    MethodCallable15<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(this, (callable as KCallable<R>).name.toGodotName())
+
+public class MethodCallable16<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14,
+    P15> @PublishedApi internal constructor(
+  target: Object,
+  methodName: StringName,
+  boundArgs: Array<Any?> = emptyArray(),
+) : MethodCallable(target, methodName, boundArgs),
+    Callable16<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> {
+  public override fun bind(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable0<R>(target, methodName,
+      arrayOf<Any?>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15,
+      *boundArgs))
+
+  public override fun bind(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable1<R, P0>(target, methodName,
+      arrayOf<Any?>(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable2<R, P0, P1>(target, methodName,
+      arrayOf<Any?>(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable3<R, P0, P1, P2>(target, methodName,
+      arrayOf<Any?>(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable4<R, P0, P1, P2, P3>(target, methodName,
+      arrayOf<Any?>(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable5<R, P0, P1, P2, P3, P4>(target, methodName,
+      arrayOf<Any?>(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable6<R, P0, P1, P2, P3, P4, P5>(target, methodName,
+      arrayOf<Any?>(p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable7<R, P0, P1, P2, P3, P4, P5, P6>(target, methodName,
+      arrayOf<Any?>(p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable8<R, P0, P1, P2, P3, P4, P5, P6, P7>(target, methodName,
+      arrayOf<Any?>(p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable9<R, P0, P1, P2, P3, P4, P5, P6, P7, P8>(target, methodName,
+      arrayOf<Any?>(p9, p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable10<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(target, methodName,
+      arrayOf<Any?>(p10, p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable11<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(target, methodName,
+      arrayOf<Any?>(p11, p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable12<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(target, methodName,
+      arrayOf<Any?>(p12, p13, p14, p15, *boundArgs))
+
+  public override fun bind(
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) = MethodCallable13<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(target, methodName,
+      arrayOf<Any?>(p13, p14, p15, *boundArgs))
+
+  public override fun bind(p14: P14, p15: P15) =
+      MethodCallable14<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(target,
+      methodName, arrayOf<Any?>(p14, p15, *boundArgs))
+
+  public override fun bind(p15: P15) =
+      MethodCallable15<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(target,
+      methodName, arrayOf<Any?>(p15, *boundArgs))
+}
+
+public fun <T : Object, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>
+    T.callable16(callable: T.(
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+  p14: P14,
+  p15: P15,
+) -> R) =
+    MethodCallable16<R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>(this, (callable as KCallable<R>).name.toGodotName())
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Signals.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Signals.kt
index bc24696e3..f6dad3f26 100644
--- a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Signals.kt
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Signals.kt
@@ -2,39 +2,32 @@
     "PackageDirectoryMismatch",
     "NOTHING_TO_INLINE",
     "UNUSED_PARAMETER",
+    "unused",
 )
 
 package godot.core
 
 import godot.api.Object
 import kotlin.Any
-import kotlin.Int
 import kotlin.PublishedApi
 import kotlin.String
 import kotlin.Suppress
 import kotlin.Unit
-import kotlin.jvm.JvmName
-import kotlin.jvm.JvmStatic
 import kotlin.properties.ReadOnlyProperty
-import kotlin.reflect.KCallable
 import kotlin.reflect.KProperty
 
 public class Signal0 @PublishedApi internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(): Unit {
-        emitSignal()
+        emitUnsafe()
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.() -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.() -> Unit): Unit =
-            disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable0<*>, flags: Object.ConnectFlags =
+            Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -42,39 +35,27 @@ public class Signal0 @PublishedApi internal constructor(
                 ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) }
 
         public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal0 =
-                Signal0(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun javaCreate(`object`: Object, signalName: String): Signal0 =
-                Signal0(`object`, signalName)
+                Signal0(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
-public inline fun Object.Signal0(signalName: String) = Signal0(this, signalName)
+public inline fun Object.Signal0(signalName: String) = Signal0(this, signalName.toGodotName())
 
 public inline fun Object.signal0() = Signal0.delegate
 
-public inline fun Signal0.connect(flags: Int = 0, noinline method: () -> Unit): Error =
-        connect(method.asCallable(), flags)
-
 public class Signal1<P0> @PublishedApi internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(p0: P0): Unit {
-        emitSignal(p0)
+        emitUnsafe(p0)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(p0: P0) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(p0: P0) -> Unit): Unit =
-            disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable1<*, P0>, flags: Object.ConnectFlags =
+            Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -82,40 +63,29 @@ public class Signal1<P0> @PublishedApi internal constructor(
                 ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) }
 
         public inline operator fun <P0> getValue(thisRef: Object, `property`: KProperty<*>):
-                Signal1<P0> = Signal1(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0> javaCreate(`object`: Object, signalName: String): Signal1<P0> =
-                Signal1(`object`, signalName)
+                Signal1<P0> = Signal1(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
-public inline fun <P0> Object.Signal1(signalName: String) = Signal1<P0>(this, signalName)
+public inline fun <P0> Object.Signal1(signalName: String) =
+        Signal1<P0>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0> Object.signal1() = Signal1.delegate as ReadOnlyProperty<Object, Signal1<P0>>
 
-public inline fun <reified P0> Signal1<P0>.connect(flags: Int = 0, noinline
-        method: (p0: P0) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal2<P0, P1> @PublishedApi internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(p0: P0, p1: P1): Unit {
-        emitSignal(p0, p1)
+        emitUnsafe(p0, p1)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(p0: P0, p1: P1) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(p0: P0, p1: P1) -> Unit): Unit =
-            disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable2<*, P0, P1>, flags: Object.ConnectFlags =
+            Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -123,52 +93,34 @@ public class Signal2<P0, P1> @PublishedApi internal constructor(
                 ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) }
 
         public inline operator fun <P0, P1> getValue(thisRef: Object, `property`: KProperty<*>):
-                Signal2<P0, P1> = Signal2(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1> javaCreate(`object`: Object, signalName: String): Signal2<P0, P1> =
-                Signal2(`object`, signalName)
+                Signal2<P0, P1> = Signal2(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
-public inline fun <P0, P1> Object.Signal2(signalName: String) = Signal2<P0, P1>(this, signalName)
+public inline fun <P0, P1> Object.Signal2(signalName: String) =
+        Signal2<P0, P1>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1> Object.signal2() =
         Signal2.delegate as ReadOnlyProperty<Object, Signal2<P0, P1>>
 
-public inline fun <reified P0, reified P1> Signal2<P0, P1>.connect(flags: Int = 0, noinline
-        method: (p0: P0, p1: P1) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal3<P0, P1, P2> @PublishedApi internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
         p1: P1,
         p2: P2,
     ): Unit {
-        emitSignal(p0, p1, p2)
+        emitUnsafe(p0, p1, p2)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable3<*, P0, P1, P2>, flags: Object.ConnectFlags =
+            Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -176,33 +128,21 @@ public class Signal3<P0, P1, P2> @PublishedApi internal constructor(
                 ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) }
 
         public inline operator fun <P0, P1, P2> getValue(thisRef: Object, `property`: KProperty<*>):
-                Signal3<P0, P1, P2> = Signal3(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2> javaCreate(`object`: Object, signalName: String):
-                Signal3<P0, P1, P2> = Signal3(`object`, signalName)
+                Signal3<P0, P1, P2> = Signal3(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2> Object.Signal3(signalName: String) =
-        Signal3<P0, P1, P2>(this, signalName)
+        Signal3<P0, P1, P2>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2> Object.signal3() =
         Signal3.delegate as ReadOnlyProperty<Object, Signal3<P0, P1, P2>>
 
-public inline fun <reified P0, reified P1, reified P2> Signal3<P0, P1, P2>.connect(flags: Int = 0,
-        noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal4<P0, P1, P2, P3> @PublishedApi internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -210,26 +150,13 @@ public class Signal4<P0, P1, P2, P3> @PublishedApi internal constructor(
         p2: P2,
         p3: P3,
     ): Unit {
-        emitSignal(p0, p1, p2, p3)
+        emitUnsafe(p0, p1, p2, p3)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable4<*, P0, P1, P2, P3>, flags: Object.ConnectFlags =
+            Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -237,34 +164,22 @@ public class Signal4<P0, P1, P2, P3> @PublishedApi internal constructor(
                 ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) }
 
         public inline operator fun <P0, P1, P2, P3> getValue(thisRef: Object,
-                `property`: KProperty<*>): Signal4<P0, P1, P2, P3> = Signal4(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3> javaCreate(`object`: Object, signalName: String):
-                Signal4<P0, P1, P2, P3> = Signal4(`object`, signalName)
+                `property`: KProperty<*>): Signal4<P0, P1, P2, P3> =
+                Signal4(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3> Object.Signal4(signalName: String) =
-        Signal4<P0, P1, P2, P3>(this, signalName)
+        Signal4<P0, P1, P2, P3>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3> Object.signal4() =
         Signal4.delegate as ReadOnlyProperty<Object, Signal4<P0, P1, P2, P3>>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3>
-        Signal4<P0, P1, P2, P3>.connect(flags: Int = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal5<P0, P1, P2, P3, P4> @PublishedApi internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -273,28 +188,13 @@ public class Signal5<P0, P1, P2, P3, P4> @PublishedApi internal constructor(
         p3: P3,
         p4: P4,
     ): Unit {
-        emitSignal(p0, p1, p2, p3, p4)
+        emitUnsafe(p0, p1, p2, p3, p4)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-            p4: P4,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable5<*, P0, P1, P2, P3, P4>, flags: Object.ConnectFlags =
+            Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -303,35 +203,21 @@ public class Signal5<P0, P1, P2, P3, P4> @PublishedApi internal constructor(
 
         public inline operator fun <P0, P1, P2, P3, P4> getValue(thisRef: Object,
                 `property`: KProperty<*>): Signal5<P0, P1, P2, P3, P4> =
-                Signal5(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3, P4> javaCreate(`object`: Object, signalName: String):
-                Signal5<P0, P1, P2, P3, P4> = Signal5(`object`, signalName)
+                Signal5(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3, P4> Object.Signal5(signalName: String) =
-        Signal5<P0, P1, P2, P3, P4>(this, signalName)
+        Signal5<P0, P1, P2, P3, P4>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3, P4> Object.signal5() =
         Signal5.delegate as ReadOnlyProperty<Object, Signal5<P0, P1, P2, P3, P4>>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4>
-        Signal5<P0, P1, P2, P3, P4>.connect(flags: Int = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal6<P0, P1, P2, P3, P4, P5> @PublishedApi internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -341,30 +227,13 @@ public class Signal6<P0, P1, P2, P3, P4, P5> @PublishedApi internal constructor(
         p4: P4,
         p5: P5,
     ): Unit {
-        emitSignal(p0, p1, p2, p3, p4, p5)
+        emitUnsafe(p0, p1, p2, p3, p4, p5)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-            p4: P4,
-            p5: P5,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable6<*, P0, P1, P2, P3, P4, P5>, flags: Object.ConnectFlags =
+            Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -373,36 +242,21 @@ public class Signal6<P0, P1, P2, P3, P4, P5> @PublishedApi internal constructor(
 
         public inline operator fun <P0, P1, P2, P3, P4, P5> getValue(thisRef: Object,
                 `property`: KProperty<*>): Signal6<P0, P1, P2, P3, P4, P5> =
-                Signal6(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3, P4, P5> javaCreate(`object`: Object, signalName: String):
-                Signal6<P0, P1, P2, P3, P4, P5> = Signal6(`object`, signalName)
+                Signal6(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3, P4, P5> Object.Signal6(signalName: String) =
-        Signal6<P0, P1, P2, P3, P4, P5>(this, signalName)
+        Signal6<P0, P1, P2, P3, P4, P5>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3, P4, P5> Object.signal6() =
         Signal6.delegate as ReadOnlyProperty<Object, Signal6<P0, P1, P2, P3, P4, P5>>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5>
-        Signal6<P0, P1, P2, P3, P4, P5>.connect(flags: Int = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal7<P0, P1, P2, P3, P4, P5, P6> @PublishedApi internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -413,32 +267,13 @@ public class Signal7<P0, P1, P2, P3, P4, P5, P6> @PublishedApi internal construc
         p5: P5,
         p6: P6,
     ): Unit {
-        emitSignal(p0, p1, p2, p3, p4, p5, p6)
+        emitUnsafe(p0, p1, p2, p3, p4, p5, p6)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-            p4: P4,
-            p5: P5,
-            p6: P6,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable7<*, P0, P1, P2, P3, P4, P5, P6>, flags: Object.ConnectFlags
+            = Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -448,37 +283,21 @@ public class Signal7<P0, P1, P2, P3, P4, P5, P6> @PublishedApi internal construc
 
         public inline operator fun <P0, P1, P2, P3, P4, P5, P6> getValue(thisRef: Object,
                 `property`: KProperty<*>): Signal7<P0, P1, P2, P3, P4, P5, P6> =
-                Signal7(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3, P4, P5, P6> javaCreate(`object`: Object, signalName: String):
-                Signal7<P0, P1, P2, P3, P4, P5, P6> = Signal7(`object`, signalName)
+                Signal7(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3, P4, P5, P6> Object.Signal7(signalName: String) =
-        Signal7<P0, P1, P2, P3, P4, P5, P6>(this, signalName)
+        Signal7<P0, P1, P2, P3, P4, P5, P6>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3, P4, P5, P6> Object.signal7() =
         Signal7.delegate as ReadOnlyProperty<Object, Signal7<P0, P1, P2, P3, P4, P5, P6>>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6> Signal7<P0, P1, P2, P3, P4, P5, P6>.connect(flags: Int = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal8<P0, P1, P2, P3, P4, P5, P6, P7> @PublishedApi internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -490,34 +309,13 @@ public class Signal8<P0, P1, P2, P3, P4, P5, P6, P7> @PublishedApi internal cons
         p6: P6,
         p7: P7,
     ): Unit {
-        emitSignal(p0, p1, p2, p3, p4, p5, p6, p7)
+        emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-            p4: P4,
-            p5: P5,
-            p6: P6,
-            p7: P7,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable8<*, P0, P1, P2, P3, P4, P5, P6, P7>,
+            flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -527,40 +325,21 @@ public class Signal8<P0, P1, P2, P3, P4, P5, P6, P7> @PublishedApi internal cons
 
         public inline operator fun <P0, P1, P2, P3, P4, P5, P6, P7> getValue(thisRef: Object,
                 `property`: KProperty<*>): Signal8<P0, P1, P2, P3, P4, P5, P6, P7> =
-                Signal8(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3, P4, P5, P6, P7> javaCreate(`object`: Object,
-                signalName: String): Signal8<P0, P1, P2, P3, P4, P5, P6, P7> =
-                Signal8(`object`, signalName)
+                Signal8(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7> Object.Signal8(signalName: String) =
-        Signal8<P0, P1, P2, P3, P4, P5, P6, P7>(this, signalName)
+        Signal8<P0, P1, P2, P3, P4, P5, P6, P7>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7> Object.signal8() =
         Signal8.delegate as ReadOnlyProperty<Object, Signal8<P0, P1, P2, P3, P4, P5, P6, P7>>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7> Signal8<P0, P1, P2, P3, P4, P5, P6, P7>.connect(flags: Int = 0, noinline
-        method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8> @PublishedApi internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -573,36 +352,13 @@ public class Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8> @PublishedApi internal
         p7: P7,
         p8: P8,
     ): Unit {
-        emitSignal(p0, p1, p2, p3, p4, p5, p6, p7, p8)
+        emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-            p4: P4,
-            p5: P5,
-            p6: P6,
-            p7: P7,
-            p8: P8,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable9<*, P0, P1, P2, P3, P4, P5, P6, P7, P8>,
+            flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -612,41 +368,21 @@ public class Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8> @PublishedApi internal
 
         public inline operator fun <P0, P1, P2, P3, P4, P5, P6, P7, P8> getValue(thisRef: Object,
                 `property`: KProperty<*>): Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8> =
-                Signal9(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8> javaCreate(`object`: Object,
-                signalName: String): Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8> =
-                Signal9(`object`, signalName)
+                Signal9(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8> Object.Signal9(signalName: String) =
-        Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8>(this, signalName)
+        Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8> Object.signal9() =
         Signal9.delegate as ReadOnlyProperty<Object, Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8>>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8> Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8>.connect(flags: Int =
-        0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> @PublishedApi internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -660,38 +396,13 @@ public class Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> @PublishedApi inte
         p8: P8,
         p9: P9,
     ): Unit {
-        emitSignal(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)
+        emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-            p4: P4,
-            p5: P5,
-            p6: P6,
-            p7: P7,
-            p8: P8,
-            p9: P9,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable10<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>,
+            flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -701,43 +412,23 @@ public class Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> @PublishedApi inte
 
         public inline operator fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>
                 getValue(thisRef: Object, `property`: KProperty<*>):
-                Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> = Signal10(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> javaCreate(`object`: Object,
-                signalName: String): Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> =
-                Signal10(`object`, signalName)
+                Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> =
+                Signal10(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> Object.Signal10(signalName: String) =
-        Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(this, signalName)
+        Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> Object.signal10() =
         Signal10.delegate as ReadOnlyProperty<Object, Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9>
-        Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>.connect(flags: Int = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> @PublishedApi internal
         constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -752,40 +443,13 @@ public class Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> @PublishedApi
         p9: P9,
         p10: P10,
     ): Unit {
-        emitSignal(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)
+        emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-            p4: P4,
-            p5: P5,
-            p6: P6,
-            p7: P7,
-            p8: P8,
-            p9: P9,
-            p10: P10,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable11<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>,
+            flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -796,45 +460,22 @@ public class Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> @PublishedApi
         public inline operator fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>
                 getValue(thisRef: Object, `property`: KProperty<*>):
                 Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> =
-                Signal11(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> javaCreate(`object`: Object,
-                signalName: String): Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> =
-                Signal11(`object`, signalName)
+                Signal11(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> Object.Signal11(signalName: String)
-        = Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(this, signalName)
+        = Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> Object.signal11() =
         Signal11.delegate as ReadOnlyProperty<Object, Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9, reified P10>
-        Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>.connect(flags: Int = 0, noinline
-        method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-    p10: P10,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> @PublishedApi internal
         constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -850,42 +491,13 @@ public class Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> @Publish
         p10: P10,
         p11: P11,
     ): Unit {
-        emitSignal(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)
+        emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-            p4: P4,
-            p5: P5,
-            p6: P6,
-            p7: P7,
-            p8: P8,
-            p9: P9,
-            p10: P10,
-            p11: P11,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public fun connect(connect: Callable12<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>,
+            flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -896,47 +508,23 @@ public class Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> @Publish
         public inline operator fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>
                 getValue(thisRef: Object, `property`: KProperty<*>):
                 Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> =
-                Signal12(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> javaCreate(`object`: Object,
-                signalName: String): Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> =
-                Signal12(`object`, signalName)
+                Signal12(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>
         Object.Signal12(signalName: String) =
-        Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(this, signalName)
+        Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> Object.signal12() =
         Signal12.delegate as ReadOnlyProperty<Object, Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9, reified P10, reified P11>
-        Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>.connect(flags: Int = 0, noinline
-        method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-    p10: P10,
-    p11: P11,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> @PublishedApi internal
         constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -953,44 +541,14 @@ public class Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> @Pu
         p11: P11,
         p12: P12,
     ): Unit {
-        emitSignal(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)
+        emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-            p4: P4,
-            p5: P5,
-            p6: P6,
-            p7: P7,
-            p8: P8,
-            p9: P9,
-            p10: P10,
-            p11: P11,
-            p12: P12,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-        p12: P12,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public
+            fun connect(connect: Callable13<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>,
+            flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -1001,49 +559,23 @@ public class Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> @Pu
         public inline operator fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>
                 getValue(thisRef: Object, `property`: KProperty<*>):
                 Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> =
-                Signal13(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>
-                javaCreate(`object`: Object, signalName: String):
-                Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> =
-                Signal13(`object`, signalName)
+                Signal13(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>
         Object.Signal13(signalName: String) =
-        Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(this, signalName)
+        Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> Object.signal13() =
         Signal13.delegate as ReadOnlyProperty<Object, Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12>
-        Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>.connect(flags: Int = 0,
-        noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-    p10: P10,
-    p11: P11,
-    p12: P12,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> @PublishedApi
         internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -1061,46 +593,14 @@ public class Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13
         p12: P12,
         p13: P13,
     ): Unit {
-        emitSignal(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)
+        emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-            p4: P4,
-            p5: P5,
-            p6: P6,
-            p7: P7,
-            p8: P8,
-            p9: P9,
-            p10: P10,
-            p11: P11,
-            p12: P12,
-            p13: P13,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-        p12: P12,
-        p13: P13,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public
+            fun connect(connect: Callable14<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>,
+            flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -1111,50 +611,23 @@ public class Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13
         public inline operator fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>
                 getValue(thisRef: Object, `property`: KProperty<*>):
                 Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> =
-                Signal14(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>
-                javaCreate(`object`: Object, signalName: String):
-                Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> =
-                Signal14(`object`, signalName)
+                Signal14(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>
         Object.Signal14(signalName: String) =
-        Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(this, signalName)
+        Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> Object.signal14() =
         Signal14.delegate as ReadOnlyProperty<Object, Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13>
-        Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>.connect(flags: Int = 0,
-        noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-    p10: P10,
-    p11: P11,
-    p12: P12,
-    p13: P13,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> @PublishedApi
         internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -1173,48 +646,14 @@ public class Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13
         p13: P13,
         p14: P14,
     ): Unit {
-        emitSignal(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)
+        emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-            p4: P4,
-            p5: P5,
-            p6: P6,
-            p7: P7,
-            p8: P8,
-            p9: P9,
-            p10: P10,
-            p11: P11,
-            p12: P12,
-            p13: P13,
-            p14: P14,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-        p12: P12,
-        p13: P13,
-        p14: P14,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public
+            fun connect(connect: Callable15<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>,
+            flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -1225,53 +664,24 @@ public class Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13
         public inline operator fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>
                 getValue(thisRef: Object, `property`: KProperty<*>):
                 Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> =
-                Signal15(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>
-                javaCreate(`object`: Object, signalName: String):
-                Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> =
-                Signal15(`object`, signalName)
+                Signal15(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>
         Object.Signal15(signalName: String) =
-        Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(this, signalName)
+        Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>
         Object.signal15() =
         Signal15.delegate as ReadOnlyProperty<Object, Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>>
 
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
-        reified P14>
-        Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>.connect(flags: Int
-        = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-    p10: P10,
-    p11: P11,
-    p12: P12,
-    p13: P13,
-    p14: P14,
-) -> Unit): Error = connect(method.asCallable(), flags)
-
 public class Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>
         @PublishedApi internal constructor(
     instance: Object,
-    name: String,
+    name: StringName,
 ) : Signal(instance, name) {
     public fun emit(
         p0: P0,
@@ -1291,50 +701,14 @@ public class Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13
         p14: P14,
         p15: P15,
     ): Unit {
-        emitSignal(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)
+        emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)
     }
 
-    public fun <T : Object> connect(
-        target: T,
-        method: T.(
-            p0: P0,
-            p1: P1,
-            p2: P2,
-            p3: P3,
-            p4: P4,
-            p5: P5,
-            p6: P6,
-            p7: P7,
-            p8: P8,
-            p9: P9,
-            p10: P10,
-            p11: P11,
-            p12: P12,
-            p13: P13,
-            p14: P14,
-            p15: P15,
-        ) -> Unit,
-        flags: Int = 0,
-    ): Error = connect(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-    public fun <T : Object> disconnect(target: T, method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-        p12: P12,
-        p13: P13,
-        p14: P14,
-        p15: P15,
-    ) -> Unit): Unit = disconnect(Callable(target, (method as KCallable<*>).name.toGodotName()))
+    public
+            fun connect(connect: Callable16<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>,
+            flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit {
+        connectUnsafe(connect, flags)
+    }
 
     public companion object {
         @PublishedApi
@@ -1345,46 +719,16 @@ public class Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13
         public inline operator fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14,
                 P15> getValue(thisRef: Object, `property`: KProperty<*>):
                 Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> =
-                Signal16(thisRef, property.name)
-
-        @JvmStatic
-        @JvmName("create")
-        public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>
-                javaCreate(`object`: Object, signalName: String):
-                Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> =
-                Signal16(`object`, signalName)
+                Signal16(thisRef, property.toGodotName())
     }
 }
 
 @Suppress("FUNCTION_NAME")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>
         Object.Signal16(signalName: String) =
-        Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>(this, signalName)
+        Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>(this, signalName.toGodotName())
 
 @Suppress("UNCHECKED_CAST")
 public inline fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>
         Object.signal16() =
         Signal16.delegate as ReadOnlyProperty<Object, Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>>
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
-        reified P14, reified P15>
-        Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>.connect(flags: Int
-        = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-    p10: P10,
-    p11: P11,
-    p12: P12,
-    p13: P13,
-    p14: P14,
-    p15: P15,
-) -> Unit): Error = connect(method.asCallable(), flags)
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/CoreType.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/CoreType.kt
index 33f22e289..02b9a9f7f 100644
--- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/CoreType.kt
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/CoreType.kt
@@ -13,4 +13,5 @@ interface CoreType
 
 abstract class NativeCoreType : CoreType, NativePointer {
     override var ptr: VoidPtr = nullptr
+        protected set
 }
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Functions.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Functions.kt
index b147de0d6..b193a16d1 100644
--- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Functions.kt
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Functions.kt
@@ -5,6 +5,7 @@ package godot.core
 import godot.common.extensions.convertToSnakeCase
 import godot.common.interop.VariantConverter
 import godot.internal.logging.GodotLogging
+import godot.internal.memory.ParametersReader
 import godot.internal.memory.TransferContext
 
 data class KtFunctionInfo(
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Variant.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Variant.kt
index 69fd14803..8f4f5c732 100644
--- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Variant.kt
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Variant.kt
@@ -284,14 +284,14 @@ enum class VariantParser(override val id: Int) : VariantConverter {
         }
     },
     AABB(16) {
-        override fun toUnsafeKotlin(buffer: ByteBuffer): godot.core.AABB {
+        override fun toUnsafeKotlin(buffer: ByteBuffer): AABB {
             val position = buffer.vector3
             val size = buffer.vector3
             return AABB(position, size)
         }
 
         override fun toUnsafeGodot(buffer: ByteBuffer, any: Any?) {
-            require(any is godot.core.AABB)
+            require(any is AABB)
             buffer.vector3 = any._position
             buffer.vector3 = any._size
         }
@@ -364,27 +364,17 @@ enum class VariantParser(override val id: Int) : VariantConverter {
     },
     OBJECT(24) {
         override fun toUnsafeKotlin(buffer: ByteBuffer) = buffer.obj
-
         override fun toUnsafeGodot(buffer: ByteBuffer, any: Any?) {
             require(any is KtObject?)
             buffer.obj = any
         }
     },
     CALLABLE(25) {
-        override fun toUnsafeKotlin(buffer: ByteBuffer): Callable {
-            val ptr = buffer.long
-            return NativeCallable(ptr)
-        }
-
+        override fun toUnsafeKotlin(buffer: ByteBuffer) = VariantCallable(buffer.long)
         override fun toUnsafeGodot(buffer: ByteBuffer, any: Any?) {
-            if (any is NativeCallable) {
-                buffer.bool = false
-                buffer.putLong(any.ptr)
-            } else {
-                require(any is LambdaCallable<*>)
-                buffer.bool = true
-                buffer.putLong(any.wrapInCustomCallable())
-            }
+            require(any is Callable)
+            // Be careful that ::toNativeCallable doesn't itself use the shared buffer.
+            buffer.putLong(any.toNativeCallable().ptr)
         }
     },
     SIGNAL(26) {
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/VariantMapper.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/VariantMapper.kt
index eaab34298..ff3432df1 100644
--- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/VariantMapper.kt
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/VariantMapper.kt
@@ -1,15 +1,16 @@
 package godot.core
 
+
 val variantMapper = mutableMapOf(
     Unit::class to VariantParser.NIL,
     Void::class to VariantParser.NIL,
     Any::class to VariantCaster.ANY,
     java.lang.Object::class to VariantCaster.ANY,
     Boolean::class to VariantParser.BOOL,
+    Byte::class to VariantCaster.BYTE,
     Int::class to VariantCaster.INT,
     Long::class to VariantParser.LONG,
     Float::class to VariantCaster.FLOAT,
-    Byte::class to VariantCaster.BYTE,
     Double::class to VariantParser.DOUBLE,
     String::class to VariantParser.STRING,
     AABB::class to VariantParser.AABB,
@@ -33,7 +34,8 @@ val variantMapper = mutableMapOf(
     Vector4::class to VariantParser.VECTOR4,
     Vector4i::class to VariantParser.VECTOR4I,
     Projection::class to VariantParser.PROJECTION,
-    NativeCallable::class to VariantParser.CALLABLE,
+    VariantCallable::class to VariantParser.CALLABLE,
+    MethodCallable::class to VariantParser.CALLABLE,
     LambdaCallable0::class to VariantParser.CALLABLE,
     LambdaCallable1::class to VariantParser.CALLABLE,
     LambdaCallable2::class to VariantParser.CALLABLE,
@@ -109,9 +111,43 @@ val notNullableVariantSet = hashSetOf(
     Vector4::class,
     Vector4i::class,
     Projection::class,
-    NativeCallable::class,
-    LambdaCallable::class,
-    Signal::class,
+    VariantCallable::class to VariantParser.CALLABLE,
+    MethodCallable::class to VariantParser.CALLABLE,
+    LambdaCallable0::class to VariantParser.CALLABLE,
+    LambdaCallable1::class to VariantParser.CALLABLE,
+    LambdaCallable2::class to VariantParser.CALLABLE,
+    LambdaCallable3::class to VariantParser.CALLABLE,
+    LambdaCallable4::class to VariantParser.CALLABLE,
+    LambdaCallable5::class to VariantParser.CALLABLE,
+    LambdaCallable6::class to VariantParser.CALLABLE,
+    LambdaCallable7::class to VariantParser.CALLABLE,
+    LambdaCallable8::class to VariantParser.CALLABLE,
+    LambdaCallable9::class to VariantParser.CALLABLE,
+    LambdaCallable10::class to VariantParser.CALLABLE,
+    LambdaCallable11::class to VariantParser.CALLABLE,
+    LambdaCallable12::class to VariantParser.CALLABLE,
+    LambdaCallable13::class to VariantParser.CALLABLE,
+    LambdaCallable14::class to VariantParser.CALLABLE,
+    LambdaCallable15::class to VariantParser.CALLABLE,
+    LambdaCallable16::class to VariantParser.CALLABLE,
+    Signal::class to VariantParser.SIGNAL,
+    Signal0::class to VariantParser.SIGNAL,
+    Signal1::class to VariantParser.SIGNAL,
+    Signal2::class to VariantParser.SIGNAL,
+    Signal3::class to VariantParser.SIGNAL,
+    Signal4::class to VariantParser.SIGNAL,
+    Signal5::class to VariantParser.SIGNAL,
+    Signal6::class to VariantParser.SIGNAL,
+    Signal7::class to VariantParser.SIGNAL,
+    Signal8::class to VariantParser.SIGNAL,
+    Signal9::class to VariantParser.SIGNAL,
+    Signal10::class to VariantParser.SIGNAL,
+    Signal11::class to VariantParser.SIGNAL,
+    Signal12::class to VariantParser.SIGNAL,
+    Signal13::class to VariantParser.SIGNAL,
+    Signal14::class to VariantParser.SIGNAL,
+    Signal15::class to VariantParser.SIGNAL,
+    Signal16::class to VariantParser.SIGNAL,
     PackedByteArray::class,
     PackedColorArray::class,
     PackedInt32Array::class,
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/bridge/Callable.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/bridge/Callable.kt
deleted file mode 100644
index a57220f6c..000000000
--- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/bridge/Callable.kt
+++ /dev/null
@@ -1,27 +0,0 @@
-@file:JvmName("Callables")
-@file:Suppress("PackageDirectoryMismatch")
-package godot.core
-
-import godot.api.Object
-
-interface Callable: CoreType {
-    fun call(vararg args: Any?): Any?
-
-    companion object {
-        @JvmStatic
-        @JvmName("create")
-        operator fun invoke() = NativeCallable()
-
-        @JvmStatic
-        @JvmName("create")
-        operator fun invoke(target: Object, methodName: StringName) = NativeCallable(target, methodName)
-
-        @JvmStatic
-        @JvmName("create")
-        operator fun invoke(nativeCallable: NativeCallable) = NativeCallable(nativeCallable)
-
-        @JvmStatic
-        @JvmName("create")
-        operator fun invoke(lambdaCallable: LambdaCallable<*>) = NativeCallable(lambdaCallable)
-    }
-}
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/bridge/LambdaCallable.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/bridge/LambdaCallable.kt
deleted file mode 100644
index 7ba390e08..000000000
--- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/bridge/LambdaCallable.kt
+++ /dev/null
@@ -1,63 +0,0 @@
-@file:Suppress("UNCHECKED_CAST", "PackageDirectoryMismatch")
-
-package godot.core
-
-import godot.common.interop.VariantConverter
-import godot.common.interop.VoidPtr
-import godot.internal.logging.GodotLogging
-import godot.internal.memory.TransferContext
-
-abstract class LambdaCallable<R : Any?>(
-    internal val variantConverter: VariantConverter,
-    internal val onCancelCall: (() -> Unit)?,
-    vararg parameterTypes: VariantConverter
-) : Callable {
-    private val types: Array<VariantConverter> = parameterTypes.toList().toTypedArray()
-
-    val returnVariantType: Int
-        get() = variantConverter.id
-
-    fun invokeNoReturn(): Unit = withParameters(types) {
-        try {
-            invokeKt()
-        } catch (t: Throwable) {
-            GodotLogging.error("Error calling a JVM custom Callable from Godot:\n" + t.stackTraceToString())
-        }
-    }
-
-    fun invokeWithReturn(): Any? = withParametersReturn(types) {
-        var ret: Any? = Unit
-        try {
-            ret = invokeKt()
-            TransferContext.writeReturnValue(ret, variantConverter)
-        } catch (t: Throwable) {
-            GodotLogging.error("Error calling a JVM custom Callable from Godot:\n" + t.stackTraceToString())
-            TransferContext.writeReturnValue(null, VariantParser.NIL)
-        }
-        ret
-    }
-
-    fun onCancel() = onCancelCall!!()
-
-    protected abstract fun invokeKt(): R
-
-    internal companion object : ParametersReader()
-
-    internal fun wrapInCustomCallable(): VoidPtr = Bridge.wrap_in_custom_callable(
-        this,
-        variantConverter.id,
-        hashCode(),
-        onCancelCall != null
-    )
-
-    @Suppress("FunctionName")
-    private object Bridge {
-        external fun wrap_in_custom_callable(
-            instance: LambdaCallable<*>,
-            variantTypeOrdinal: Int,
-            hashCode: Int,
-            hasOnCancel: Boolean
-        ): VoidPtr
-    }
-}
-
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/bridge/NativeCallable.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/bridge/NativeCallable.kt
deleted file mode 100644
index ee0b550b5..000000000
--- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/bridge/NativeCallable.kt
+++ /dev/null
@@ -1,229 +0,0 @@
-@file:JvmName("CallableUtils")
-@file:Suppress("PackageDirectoryMismatch")
-
-package godot.core
-
-import godot.api.Object
-import godot.common.interop.ObjectID
-import godot.internal.memory.MemoryManager
-import godot.internal.memory.TransferContext
-import godot.common.interop.VoidPtr
-import kotlin.reflect.KCallable
-
-class NativeCallable : NativeCoreType, Callable {
-
-    internal constructor() {
-        ptr = Bridge.engine_call_constructor()
-        MemoryManager.registerNativeCoreType(this, VariantParser.CALLABLE)
-    }
-
-    internal constructor(target: Object, methodName: StringName) {
-        TransferContext.writeArguments(VariantParser.OBJECT to target, VariantParser.STRING_NAME to methodName)
-        ptr = Bridge.engine_call_constructor_object_string_name()
-        MemoryManager.registerNativeCoreType(this, VariantParser.CALLABLE)
-    }
-
-    internal constructor(callable: NativeCallable) {
-        TransferContext.writeArguments(VariantParser.CALLABLE to callable)
-        ptr = Bridge.engine_call_copy_constructor()
-        MemoryManager.registerNativeCoreType(this, VariantParser.CALLABLE)
-    }
-
-    internal constructor(lambdaCallable: LambdaCallable<*>) {
-        // We pass all params using jni as we're often in a context of sending parameters to cpp, so we should not rewind buffer.
-        ptr = Bridge.engine_call_constructor_kt_custom_callable(lambdaCallable, lambdaCallable.variantConverter.id, lambdaCallable.hashCode(), lambdaCallable.onCancelCall != null)
-        MemoryManager.registerNativeCoreType(this, VariantParser.CALLABLE)
-    }
-
-    internal constructor(_handle: VoidPtr){
-        this.ptr = _handle
-        MemoryManager.registerNativeCoreType(this, VariantParser.CALLABLE)
-    }
-
-    fun bind(vararg args: Any?): NativeCallable {
-        TransferContext.writeArguments(*args.map { VariantCaster.ANY to it }.toTypedArray())
-        Bridge.engine_call_bind(ptr)
-        return TransferContext.readReturnValue(VariantParser.CALLABLE) as NativeCallable
-    }
-
-    fun bindv(args: VariantArray<Any?>): NativeCallable {
-        TransferContext.writeArguments(VariantParser.ARRAY to args)
-        Bridge.engine_call_bindv(ptr)
-        return TransferContext.readReturnValue(VariantParser.CALLABLE) as NativeCallable
-    }
-
-    override fun call(vararg args: Any?): Any? {
-        TransferContext.writeArguments(*args.map { VariantCaster.ANY to it }.toTypedArray())
-        Bridge.engine_call_call(ptr)
-        return TransferContext.readReturnValue(VariantCaster.ANY)
-    }
-
-    fun callDeferred(vararg args: Any?) {
-        TransferContext.writeArguments(*args.map { VariantCaster.ANY to it }.toTypedArray())
-        Bridge.engine_call_call_deferred(ptr)
-    }
-
-    fun callv(args: VariantArray<Any?>): Any? {
-        TransferContext.writeArguments(VariantParser.ARRAY to args)
-        Bridge.engine_call_callv(ptr)
-        return TransferContext.readReturnValue(VariantCaster.ANY)
-    }
-
-    fun getBoundArguments(): VariantArray<Any?> {
-        Bridge.engine_call_get_bound_arguments(ptr)
-        @Suppress("UNCHECKED_CAST")
-        return TransferContext.readReturnValue(VariantParser.ARRAY) as VariantArray<Any?>
-    }
-
-    fun getBoundArgumentCount(): Int {
-        Bridge.engine_call_get_bound_arguments_count(ptr)
-        return TransferContext.readReturnValue(VariantCaster.INT) as Int
-    }
-
-    fun getMethod(): StringName {
-        Bridge.engine_call_get_method(ptr)
-        return TransferContext.readReturnValue(VariantParser.STRING_NAME) as StringName
-    }
-
-    fun getObject(): Object {
-        Bridge.engine_call_get_object(ptr)
-        return TransferContext.readReturnValue(VariantParser.OBJECT) as Object
-    }
-
-    fun getObjectId(): ObjectID {
-        Bridge.engine_call_get_object_id(ptr)
-        return ObjectID(TransferContext.readReturnValue(VariantParser.LONG) as Long)
-    }
-
-    override fun hashCode(): Int {
-        Bridge.engine_call_hash(ptr)
-        return TransferContext.readReturnValue(VariantCaster.INT) as Int
-    }
-
-    fun isCustom(): Boolean {
-        Bridge.engine_call_is_custom(ptr)
-        return TransferContext.readReturnValue(VariantParser.BOOL) as Boolean
-    }
-
-    fun isNull(): Boolean {
-        Bridge.engine_call_is_null(ptr)
-        return TransferContext.readReturnValue(VariantParser.BOOL) as Boolean
-    }
-
-    fun isStandard(): Boolean {
-        Bridge.engine_call_is_standard(ptr)
-        return TransferContext.readReturnValue(VariantParser.BOOL) as Boolean
-    }
-
-    fun isValid(): Boolean {
-        Bridge.engine_call_is_valid(ptr)
-        return TransferContext.readReturnValue(VariantParser.BOOL) as Boolean
-    }
-
-    fun rpc(vararg args: Any?) {
-        TransferContext.writeArguments(*args.map { VariantCaster.ANY to it }.toTypedArray())
-        Bridge.engine_call_rpc(ptr)
-    }
-
-    fun rpcId(peerId: Long, vararg args: Any?) {
-        TransferContext.writeArguments(VariantParser.LONG to peerId, *args.map { VariantCaster.ANY to it }.toTypedArray())
-        Bridge.engine_call_rpc_id(ptr)
-    }
-
-    fun unbind(argCount: Int): NativeCallable {
-        TransferContext.writeArguments(VariantCaster.INT to argCount)
-        Bridge.engine_call_unbind(ptr)
-        return TransferContext.readReturnValue(VariantParser.CALLABLE) as NativeCallable
-    }
-
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (other !is NativeCallable) return false
-        if(getObject() != other.getObject() || getMethod() != other.getMethod()) return false
-        return true
-    }
-
-    @Suppress("FunctionName")
-    object Bridge {
-        external fun engine_call_constructor(): VoidPtr
-        external fun engine_call_constructor_object_string_name(): VoidPtr
-        external fun engine_call_constructor_kt_custom_callable(callable: LambdaCallable<*>, variantTypeOrdinal: Int, hashCode: Int, hasOnCancel: Boolean): VoidPtr
-        external fun engine_call_copy_constructor(): VoidPtr
-
-        external fun engine_call_bind(_handle: VoidPtr)
-        external fun engine_call_bindv(_handle: VoidPtr)
-        external fun engine_call_call(handle: VoidPtr)
-        external fun engine_call_call_deferred(handle: VoidPtr)
-        external fun engine_call_callv(_handle: VoidPtr)
-        external fun engine_call_get_bound_arguments(_handle: VoidPtr)
-        external fun engine_call_get_bound_arguments_count(_handle: VoidPtr)
-        external fun engine_call_get_method(_handle: VoidPtr)
-        external fun engine_call_get_object(_handle: VoidPtr)
-        external fun engine_call_get_object_id(_handle: VoidPtr)
-        external fun engine_call_hash(_handle: VoidPtr)
-        external fun engine_call_is_custom(_handle: VoidPtr)
-        external fun engine_call_is_null(_handle: VoidPtr)
-        external fun engine_call_is_standard(_handle: VoidPtr)
-        external fun engine_call_is_valid(_handle: VoidPtr)
-        external fun engine_call_rpc(_handle: VoidPtr)
-        external fun engine_call_rpc_id(_handle: VoidPtr)
-        external fun engine_call_unbind(_handle: VoidPtr)
-    }
-
-    companion object {
-        operator fun <T : Object> invoke(
-            target: T,
-            callable: T.() -> Unit
-        ) = NativeCallable(target, (callable as KCallable<*>).name.toGodotName())
-
-        operator fun <T : Object, P> invoke(
-            target: T,
-            callable: T.(P) -> Unit
-        ) = NativeCallable(target, (callable as KCallable<*>).name.toGodotName())
-
-        operator fun <T : Object, P1, P2> invoke(
-            target: T,
-            callable: T.(P1, P2) -> Unit
-        ) = NativeCallable(target, (callable as KCallable<*>).name.toGodotName())
-
-        operator fun <T : Object, P1, P2, P3> invoke(
-            target: T,
-            callable: T.(P1, P2, P3) -> Unit
-        ) = NativeCallable(target, (callable as KCallable<*>).name.toGodotName())
-
-        operator fun <T : Object, P1, P2, P3, P4> invoke(
-            target: T,
-            callable: T.(P1, P2, P3, P4) -> Unit
-        ) = NativeCallable(target, (callable as KCallable<*>).name.toGodotName())
-
-        operator fun <T : Object, P1, P2, P3, P4, P5> invoke(
-            target: T,
-            callable: T.(P1, P2, P3, P4, P5) -> Unit
-        ) = NativeCallable(target, (callable as KCallable<*>).name.toGodotName())
-
-        operator fun <T : Object, P1, P2, P3, P4, P5, P6> invoke(
-            target: T,
-            callable: T.(P1, P2, P3, P4, P5, P6) -> Unit
-        ) = NativeCallable(target, (callable as KCallable<*>).name.toGodotName())
-
-        operator fun <T : Object, P1, P2, P3, P4, P5, P6, P7> invoke(
-            target: T,
-            callable: T.(P1, P2, P3, P4, P5, P6, P7) -> Unit
-        ) = NativeCallable(target, (callable as KCallable<*>).name.toGodotName())
-
-        operator fun <T : Object, P1, P2, P3, P4, P5, P6, P7, P8> invoke(
-            target: T,
-            callable: T.(P1, P2, P3, P4, P5, P6, P7, P8) -> Unit
-        ) = NativeCallable(target, (callable as KCallable<*>).name.toGodotName())
-
-        operator fun <T : Object, P1, P2, P3, P4, P5, P6, P7, P8, P9> invoke(
-            target: T,
-            callable: T.(P1, P2, P3, P4, P5, P6, P7, P8, P9) -> Unit
-        ) = NativeCallable(target, (callable as KCallable<*>).name.toGodotName())
-
-        operator fun <T : Object, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> invoke(
-            target: T,
-            callable: T.(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) -> Unit
-        ) = NativeCallable(target, (callable as KCallable<*>).name.toGodotName())
-    }
-}
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Callable.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Callable.kt
new file mode 100644
index 000000000..d4aed64b5
--- /dev/null
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Callable.kt
@@ -0,0 +1,173 @@
+@file:Suppress("PackageDirectoryMismatch")
+
+package godot.core
+
+import godot.api.Object
+import godot.common.interop.ObjectID
+import godot.common.interop.VoidPtr
+
+/**
+ * Callable is a built-in Variant type that represents a function.
+ *
+ * It can either be a method within an Object instance, or a custom callable used for different purposes (see is_custom).
+ *
+ * Like all Variant types, it can be stored in variables and passed to other functions. It is most commonly used for signal callbacks.
+ *
+ * This JVM version added an "unsafe" prefix to several methods. It's encouraged to use the typed version of those methods instead.
+ */
+interface Callable : CoreType {
+    /**
+     * Returns a copy of this Callable with one or more arguments bound.
+     * When called, the bound arguments are passed after the arguments supplied by call. See also unbind.
+     *
+     * Note: When this method is chained with other similar methods, the order in which the argument list is modified is read from right to left.
+     */
+    fun bindUnsafe(vararg args: Any?): Callable
+
+
+    /**
+     * Calls the method represented by this Callable. Arguments can be passed and should match the method's signature.
+     * */
+    fun callUnsafe(vararg args: Any?): Any?
+
+    /**Calls the method represented by this Callable in deferred mode, i.e. at the end of the current frame.
+     * Arguments can be passed and should match the method's signature.
+     *
+     * Note: Deferred calls are processed at idle time.
+     * Idle time happens mainly at the end of process and physics frames.
+     * In it, deferred calls will be run until there are none left, which means you can defer calls from other deferred calls and they'll still be run in the current idle time cycle.
+     * This means you should not call a method deferred from itself (or from a method called by it), as this causes infinite recursion the same way as if you had called the method directly.
+     */
+    fun callDeferredUnsafe(vararg args: Any?)
+
+    /**
+     * Returns the array of arguments bound via successive bind or unbind calls. These arguments will be added after the arguments passed to the call, from which get_unbound_arguments_count arguments on the right have been previously excluded.
+     * */
+    fun getBoundArguments(): Collection<Any?>
+
+    /**
+     * Returns the total amount of arguments bound via successive bind or unbind calls. This is the same as the size of the array returned by get_bound_arguments. See get_bound_arguments for details
+     *
+     * Note: The get_bound_arguments_count and get_unbound_arguments_count methods can both return positive values.
+     * */
+    fun getBoundArgumentCount(): Int
+
+    /**
+     * Returns the name of the method represented by this Callable.
+     * If the callable is a GDScript lambda function, returns the function's name or "<anonymous lambda>".
+     */
+    fun getMethod(): StringName
+
+    /**Returns the object on which this Callable is called.*/
+    fun getObject(): Object?
+
+    /**Returns the ID of this Callable's object (see [Object.getInstanceId]).*/
+    fun getObjectId(): ObjectID
+
+    /**
+     * Returns true if this Callable is a custom callable. Custom callables are used:
+     *
+     * -for binding/unbinding arguments (see bind and unbind);
+     *
+     * -for representing methods of built-in Variant types (see create);
+     *
+     * -for representing global, lambda, and RPC functions in GDScript;
+     *
+     * -for other purposes in the core, GDExtension, and C#.
+     * */
+    fun isCustom(): Boolean
+
+    /**
+     * Returns true if this Callable has no target to call the method on. Equivalent to callable == Callable().
+     *
+     * Note: This is not the same as not is_valid() and using not is_null() will not guarantee that this callable can be called.
+     * Use is_valid instead.*/
+    fun isNull(): Boolean
+
+    /**
+     * Returns true if this Callable is a standard callable.
+     * This method is the opposite of is_custom. Returns false if this callable is a lambda function.
+     * */
+    fun isStandard(): Boolean
+
+    /**
+     * Returns true if the callable's object exists and has a valid method name assigned, or is a custom callable.
+     */
+    fun isValid(): Boolean
+
+    /**
+     * Perform an RPC (Remote Procedure Call) on all connected peers.
+     * This is used for multiplayer and is normally not available, unless the function being called has been marked as RPC (using @GDScript.@rpc or Node.rpc_config).
+     * Calling this method on unsupported functions will result in an error. See Node.rpc.
+     * */
+    fun rpc(vararg args: Any?)
+
+    /**
+     * Perform an RPC (Remote Procedure Call) on a specific peer ID (see multiplayer documentation for reference).
+     * This is used for multiplayer and is normally not available unless the function being called has been marked as RPC (using @GDScript.@rpc or Node.rpc_config).
+     * Calling this method on unsupported functions will result in an error. See Node.rpc_id.
+     * */
+    fun rpcId(peerId: Long, vararg args: Any?)
+
+    /**
+     * Returns a copy of this Callable with a number of arguments unbound.
+     * In other words, when the new callable is called the last few arguments supplied by the user are ignored, according to argcount.
+     * The remaining arguments are passed to the callable.
+     * This allows to use the original callable in a context that attempts to pass more arguments than this callable can handle, e.g. a signal with a fixed number of arguments.
+     * See also [bindUnsafe].
+     *
+     * Note: When this method is chained with other similar methods, the order in which the argument list is modified is read from right to left.
+     * */
+    fun unbind(argCount: Int): VariantCallable
+
+    fun toNativeCallable(): VariantCallable
+
+    companion object {
+        @JvmSynthetic
+        operator fun invoke() = VariantCallable()
+
+        @JvmStatic
+        fun createUnsafe(target: Object, methodName: StringName) = MethodCallable(target, methodName)
+    }
+
+    @Suppress("FunctionName")
+    object Bridge {
+        external fun engine_call_constructor(): VoidPtr
+        external fun engine_call_constructor_object_string_name(
+            objectPtr: VoidPtr,
+            methodNamePtr: VoidPtr
+        ): VoidPtr
+        external fun engine_call_constructor_lambda_callable(
+            container: LambdaContainer<*>,
+            variantTypeOrdinal: Int,
+            hashCode: Int,
+        ): VoidPtr
+
+        external fun engine_call_constructor_cancellable(
+            container: LambdaContainer<*>,
+            variantTypeOrdinal: Int,
+            hashCode: Int,
+        )
+
+        external fun engine_call_copy_constructor(): VoidPtr
+
+        external fun engine_call_bind(handle: VoidPtr)
+        external fun engine_call_call(handle: VoidPtr)
+        external fun engine_call_call_deferred(handle: VoidPtr)
+        external fun engine_call_get_bound_arguments(handle: VoidPtr)
+        external fun engine_call_get_bound_arguments_count(handle: VoidPtr)
+        external fun engine_call_get_method(handle: VoidPtr)
+        external fun engine_call_get_object(handle: VoidPtr)
+        external fun engine_call_get_object_id(handle: VoidPtr)
+        external fun engine_call_hash(handle: VoidPtr)
+        external fun engine_call_is_custom(handle: VoidPtr)
+        external fun engine_call_is_null(handle: VoidPtr)
+        external fun engine_call_is_standard(handle: VoidPtr)
+        external fun engine_call_is_valid(handle: VoidPtr)
+        external fun engine_call_rpc(handle: VoidPtr)
+        external fun engine_call_rpc_id(handle: VoidPtr)
+        external fun engine_call_unbind(handle: VoidPtr)
+    }
+}
+
+fun unsafeCallable(target: Object, methodName: StringName) = MethodCallable(target, methodName)
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/LambdaCallable.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/LambdaCallable.kt
new file mode 100644
index 000000000..ec53bdbc5
--- /dev/null
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/LambdaCallable.kt
@@ -0,0 +1,99 @@
+@file:Suppress("UNCHECKED_CAST", "PackageDirectoryMismatch", "unused")
+
+package godot.core
+
+import godot.common.interop.ObjectID
+import godot.common.interop.VariantConverter
+import godot.core.Callable.Bridge
+import godot.internal.logging.GodotLogging
+import godot.internal.memory.ParametersReader
+import godot.internal.memory.TransferContext
+
+open class LambdaCallable<R> internal constructor(
+    protected val container: LambdaContainer<R>,
+    protected var boundArgs: Array<out Any?> = emptyArray()
+) : Callable {
+
+    override fun getBoundArguments() = boundArgs.toList()
+    override fun getBoundArgumentCount() = boundArgs.size
+    override fun getMethod() = StringName()
+    override fun getObject() = null
+    override fun getObjectId() = ObjectID(0)
+    override fun isCustom() = true
+    override fun isNull() = false
+    override fun isStandard() = false
+    override fun isValid() = true
+    override fun rpc(vararg args: Any?) = throw UnsupportedOperationException("Can't make a RPC call from a LambdaCallable")
+    override fun rpcId(peerId: Long, vararg args: Any?) = throw UnsupportedOperationException("Can't make a RPC call from a LambdaCallable")
+    override fun unbind(argCount: Int) = toNativeCallable().unbind(argCount)
+    override fun bindUnsafe(vararg args: Any?) = LambdaCallable<R>(container, arrayOf<Any?>(*args, *boundArgs))
+    override fun callUnsafe(vararg args: Any?) = container.invokeUnsafe(*args, *boundArgs)
+    override fun callDeferredUnsafe(vararg args: Any?) {
+        val ptr = Bridge.engine_call_constructor_lambda_callable(container, container.returnConverter.id, hashCode())
+        // We could use the [toVariantCallable] function, but we want to avoid 1 additional JNI calls in case we have bound arguments.
+        VariantCallable(ptr).callDeferredUnsafe(*args, *boundArgs)
+    }
+
+    /**
+     * Get rid of the lambda contained in this Callable, this instance won't be usable anymore after calling it.
+     * Custom Callable can create reference cycles between Godot and the JVM which can make part of your objects unable to be freed by the Garbage Collector.
+     * This method is a last resort that can allow you to break a cycle caused by the Callable keeping its captured instance alive when itself is kept alive by the C++ side.
+     */
+    fun invalidate() = container.invalidate()
+    override fun toNativeCallable(): VariantCallable {
+        // We pass all params using jni as we're often in a context of sending parameters to cpp, so we should not rewind buffer.
+        val ptr = Bridge.engine_call_constructor_lambda_callable(container, container.returnConverter.id, hashCode())
+        val unbound = VariantCallable(ptr)
+        if (boundArgs.isNotEmpty()) {
+            return unbound.bindUnsafe(*boundArgs)
+        }
+        return unbound
+    }
+}
+
+abstract class LambdaContainer<R>(
+    val returnConverter: VariantConverter,
+    val typeConverters: Array<VariantConverter>,
+    var function: Function<R>?
+) {
+    var cancelFunction: (() -> Unit)? = null
+    fun cancel() {
+        cancelFunction?.invoke()
+    }
+
+    fun setAsCancellable(signal: Signal, block: () -> Unit) {
+        cancelFunction = block
+        TransferContext.writeArguments(VariantParser.SIGNAL to signal)
+        Bridge.engine_call_constructor_cancellable(this, this.returnConverter.id, hashCode())
+    }
+
+    abstract fun invokeUnsafe(vararg args: Any?): R
+
+    fun invoke() = withParameters(typeConverters) {
+        try {
+            invokeUnsafe(*paramsArray)
+        } catch (t: Throwable) {
+            GodotLogging.error("Error calling a JVM custom Callable from Godot:\n" + t.stackTraceToString())
+        }
+    }
+
+    fun invokeWithReturn(): Any? = withParametersReturn(typeConverters) {
+        val ret: Any? = null
+        try {
+            val ret = invokeUnsafe(*paramsArray)
+            TransferContext.writeReturnValue(ret, returnConverter)
+        } catch (t: Throwable) {
+            GodotLogging.error("Error calling a JVM custom Callable from Godot:\n" + t.stackTraceToString())
+            TransferContext.writeReturnValue(null, VariantParser.NIL)
+        }
+        ret
+    }
+
+    fun invalidate(): Unit {
+        function = null
+    }
+
+    internal companion object : ParametersReader()
+}
+
+class InvalidJvmLambdaException : Exception("This LambdaCallable has been invalidated, it shouldn't be called. Make sure to disconnect it from any signals")
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt
new file mode 100644
index 000000000..e8d225b37
--- /dev/null
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt
@@ -0,0 +1,44 @@
+@file:Suppress("PackageDirectoryMismatch")
+
+package godot.core
+
+import godot.api.Object
+import godot.core.Callable.Bridge
+import godot.internal.memory.MemoryManager
+
+open class MethodCallable internal constructor(
+    protected val target: Object,
+    protected val methodName: StringName,
+    protected var boundArgs: Array<out Any?> = emptyArray()
+) : Callable {
+
+    constructor(target: Object, methodName: StringName) : this(target, methodName, emptyArray())
+
+    override fun getBoundArguments() = boundArgs.toList()
+    override fun getBoundArgumentCount() = boundArgs.size
+    override fun getMethod() = methodName
+    override fun getObject() = target
+    override fun getObjectId() = target.objectID
+    override fun isCustom() = false
+    override fun isNull() = false
+    override fun isStandard() = true
+    override fun isValid() = MemoryManager.isInstanceValid(target) && target.hasMethod(methodName)
+    override fun rpc(vararg args: Any?) = toNativeCallable().rpc(args)
+    override fun rpcId(peerId: Long, vararg args: Any?) = toNativeCallable().rpcId(peerId, args)
+    override fun unbind(argCount: Int) = toNativeCallable().unbind(argCount)
+    override fun bindUnsafe(vararg args: Any?) = MethodCallable(target, methodName, arrayOf<Any?>(*args, *boundArgs))
+    override fun callUnsafe(vararg args: Any?) = target.call(methodName, *args, *boundArgs)
+    override fun callDeferredUnsafe(vararg args: Any?) {
+        target.callDeferred(methodName, *args, *boundArgs)
+    }
+
+    override fun toNativeCallable(): VariantCallable {
+        // We pass all params using jni as we're often in a context of sending parameters to cpp, so we should not rewind buffer.
+        val ptr = Bridge.engine_call_constructor_object_string_name(target.ptr, methodName.ptr)
+        val unbound = VariantCallable(ptr)
+        if (boundArgs.isNotEmpty()) {
+            return unbound.bindUnsafe(*boundArgs)
+        }
+        return unbound
+    }
+}
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Signal.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Signal.kt
similarity index 65%
rename from kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Signal.kt
rename to kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Signal.kt
index e9ecc58ef..cdd830a58 100644
--- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Signal.kt
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Signal.kt
@@ -1,6 +1,9 @@
+@file:Suppress("PackageDirectoryMismatch")
+
 package godot.core
 
 import godot.api.Object
+import godot.api.Object.ConnectFlags
 import godot.common.extensions.convertToSnakeCase
 import godot.internal.memory.MemoryManager
 
@@ -9,27 +12,24 @@ open class Signal internal constructor(
     val name: StringName
 ) : CoreType {
 
-    internal constructor(instance: Object, jvmName: String) : this(
-        instance,
-        jvmName.convertToSnakeCase().asStringName()
-    )
-
-    fun emitSignal(vararg args: Any?) {
+    fun emitUnsafe(vararg args: Any?) {
         godotObject.emitSignal(name, *args)
     }
 
-    fun connect(
+    fun connectUnsafe(
         callable: Callable,
-        flags: Int = 0
-    ) = godotObject.connect(name, callable, flags.toLong())
+        flags: ConnectFlags = ConnectFlags.DEFAULT
+    ) = godotObject.connect(name, callable, flags)
 
-    fun disconnect(callable: Callable) = godotObject.disconnect(name, callable)
+    fun disconnectUnsafe(callable: Callable) = godotObject.disconnect(name, callable)
 
     fun getConnections() = godotObject.getSignalConnectionList(name)
 
+    fun hasConnections() = godotObject.hasConnections(name)
+
     fun isConnected(callable: Callable) = godotObject.isConnected(name, callable)
 
-    fun isNull() = !(MemoryManager.isInstanceValid(godotObject) && godotObject.hasSignal(name))
+    fun isValid() = MemoryManager.isInstanceValid(godotObject) && godotObject.hasSignal(name)
 
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/VariantCallable.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/VariantCallable.kt
new file mode 100644
index 000000000..6aa349175
--- /dev/null
+++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/VariantCallable.kt
@@ -0,0 +1,123 @@
+@file:Suppress("PackageDirectoryMismatch")
+
+package godot.core
+
+import godot.api.Object
+import godot.common.interop.ObjectID
+import godot.common.interop.VoidPtr
+import godot.core.Callable.Bridge
+import godot.internal.memory.MemoryManager
+import godot.internal.memory.TransferContext
+import kotlin.reflect.KCallable
+
+class VariantCallable : NativeCoreType, Callable {
+
+    internal constructor() {
+        ptr = Bridge.engine_call_constructor()
+        MemoryManager.registerNativeCoreType(this, VariantParser.CALLABLE)
+    }
+
+    internal constructor(callable: VariantCallable) {
+        TransferContext.writeArguments(VariantParser.CALLABLE to callable)
+        ptr = Bridge.engine_call_copy_constructor()
+        MemoryManager.registerNativeCoreType(this, VariantParser.CALLABLE)
+    }
+
+    internal constructor(handle: VoidPtr) {
+        this.ptr = handle
+        MemoryManager.registerNativeCoreType(this, VariantParser.CALLABLE)
+    }
+
+    override fun bindUnsafe(vararg args: Any?): VariantCallable {
+        TransferContext.writeArguments(*args.map { VariantCaster.ANY to it }.toTypedArray())
+        Bridge.engine_call_bind(ptr)
+        return TransferContext.readReturnValue(VariantParser.CALLABLE) as VariantCallable
+    }
+
+    override fun callUnsafe(vararg args: Any?): Any? {
+        TransferContext.writeArguments(*args.map { VariantCaster.ANY to it }.toTypedArray())
+        Bridge.engine_call_call(ptr)
+        return TransferContext.readReturnValue(VariantCaster.ANY)
+    }
+
+    override fun callDeferredUnsafe(vararg args: Any?) {
+        TransferContext.writeArguments(*args.map { VariantCaster.ANY to it }.toTypedArray())
+        Bridge.engine_call_call_deferred(ptr)
+    }
+
+    override fun getBoundArguments(): VariantArray<Any?> {
+        Bridge.engine_call_get_bound_arguments(ptr)
+        @Suppress("UNCHECKED_CAST")
+        return TransferContext.readReturnValue(VariantParser.ARRAY) as VariantArray<Any?>
+    }
+
+    override fun getBoundArgumentCount(): Int {
+        Bridge.engine_call_get_bound_arguments_count(ptr)
+        return TransferContext.readReturnValue(VariantCaster.INT) as Int
+    }
+
+    override fun getMethod(): StringName {
+        Bridge.engine_call_get_method(ptr)
+        return TransferContext.readReturnValue(VariantParser.STRING_NAME) as StringName
+    }
+
+    override fun hashCode(): Int {
+        Bridge.engine_call_hash(ptr)
+        return TransferContext.readReturnValue(VariantCaster.INT) as Int
+    }
+
+    override fun getObject(): Object {
+        Bridge.engine_call_get_object(ptr)
+        return TransferContext.readReturnValue(VariantParser.OBJECT) as Object
+    }
+
+    override fun getObjectId(): ObjectID {
+        Bridge.engine_call_get_object_id(ptr)
+        return ObjectID(TransferContext.readReturnValue(VariantParser.LONG) as Long)
+    }
+
+    override fun isCustom(): Boolean {
+        Bridge.engine_call_is_custom(ptr)
+        return TransferContext.readReturnValue(VariantParser.BOOL) as Boolean
+    }
+
+    override fun isNull(): Boolean {
+        Bridge.engine_call_is_null(ptr)
+        return TransferContext.readReturnValue(VariantParser.BOOL) as Boolean
+    }
+
+    override fun isStandard(): Boolean {
+        Bridge.engine_call_is_standard(ptr)
+        return TransferContext.readReturnValue(VariantParser.BOOL) as Boolean
+    }
+
+    override fun isValid(): Boolean {
+        Bridge.engine_call_is_valid(ptr)
+        return TransferContext.readReturnValue(VariantParser.BOOL) as Boolean
+    }
+
+    override fun rpc(vararg args: Any?) {
+        TransferContext.writeArguments(*args.map { VariantCaster.ANY to it }.toTypedArray())
+        Bridge.engine_call_rpc(ptr)
+    }
+
+    override fun rpcId(peerId: Long, vararg args: Any?) {
+        TransferContext.writeArguments(VariantParser.LONG to peerId, *args.map { VariantCaster.ANY to it }.toTypedArray())
+        Bridge.engine_call_rpc_id(ptr)
+    }
+
+    override fun unbind(argCount: Int): VariantCallable {
+        TransferContext.writeArguments(VariantCaster.INT to argCount)
+        Bridge.engine_call_unbind(ptr)
+        return TransferContext.readReturnValue(VariantParser.CALLABLE) as VariantCallable
+    }
+
+    override fun toNativeCallable() = this
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is VariantCallable) return false
+        if (getObject() != other.getObject() || getMethod() != other.getMethod()) return false
+        return true
+    }
+}
diff --git a/kt/godot-library/godot-coroutine-library/src/main/kotlin/gen/godot/coroutines/Await.kt b/kt/godot-library/godot-coroutine-library/src/main/kotlin/gen/godot/coroutines/Await.kt
index df79e0ee5..3387960d6 100644
--- a/kt/godot-library/godot-coroutine-library/src/main/kotlin/gen/godot/coroutines/Await.kt
+++ b/kt/godot-library/godot-coroutine-library/src/main/kotlin/gen/godot/coroutines/Await.kt
@@ -2,7 +2,6 @@
 
 package godot.coroutines
 
-import godot.api.Object
 import godot.core.Signal0
 import godot.core.Signal1
 import godot.core.Signal10
@@ -20,8 +19,7 @@ import godot.core.Signal6
 import godot.core.Signal7
 import godot.core.Signal8
 import godot.core.Signal9
-import godot.core.asCallable
-import godot.extension.connectThreadSafe
+import godot.extension.promise
 import kotlin.Suppress
 import kotlin.Unit
 import kotlin.coroutines.resume
@@ -30,25 +28,19 @@ import kotlinx.coroutines.suspendCancellableCoroutine
 
 public suspend inline fun Signal0.await(): Unit = suspendCancellableCoroutine {
     cont: CancellableContinuation<Unit> ->
-    connectThreadSafe( {
-         ->
-        cont.resume(Unit)
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    {  -> cont.resume(Unit) },
+    { cont.cancel() },
+    )
+}
 
 public suspend inline fun <reified P0> Signal1<P0>.await(): P0 = suspendCancellableCoroutine {
     cont: CancellableContinuation<P0> ->
-    connectThreadSafe( {
-        p0: P0 ->
-        cont.resume(p0)
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0 -> cont.resume(p0) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments2<P0, P1>(
     public val p0: P0,
@@ -58,14 +50,11 @@ public data class SignalArguments2<P0, P1>(
 public suspend inline fun <reified P0, reified P1> Signal2<P0, P1>.await(): SignalArguments2<P0, P1>
         = suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments2<P0, P1>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1 ->
-        cont.resume(SignalArguments2(p0, p1))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1 -> cont.resume(SignalArguments2(p0, p1)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments3<P0, P1, P2>(
     public val p0: P0,
@@ -76,14 +65,11 @@ public data class SignalArguments3<P0, P1, P2>(
 public suspend inline fun <reified P0, reified P1, reified P2> Signal3<P0, P1, P2>.await():
         SignalArguments3<P0, P1, P2> = suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments3<P0, P1, P2>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2 ->
-        cont.resume(SignalArguments3(p0, p1, p2))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2 -> cont.resume(SignalArguments3(p0, p1, p2)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments4<P0, P1, P2, P3>(
     public val p0: P0,
@@ -96,14 +82,11 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3>
         Signal4<P0, P1, P2, P3>.await(): SignalArguments4<P0, P1, P2, P3> =
         suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments4<P0, P1, P2, P3>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3 ->
-        cont.resume(SignalArguments4(p0, p1, p2, p3))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3 -> cont.resume(SignalArguments4(p0, p1, p2, p3)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments5<P0, P1, P2, P3, P4>(
     public val p0: P0,
@@ -117,14 +100,11 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3, reifi
         Signal5<P0, P1, P2, P3, P4>.await(): SignalArguments5<P0, P1, P2, P3, P4> =
         suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments5<P0, P1, P2, P3, P4>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 ->
-        cont.resume(SignalArguments5(p0, p1, p2, p3, p4))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 -> cont.resume(SignalArguments5(p0, p1, p2, p3, p4)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments6<P0, P1, P2, P3, P4, P5>(
     public val p0: P0,
@@ -139,14 +119,11 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3, reifi
         Signal6<P0, P1, P2, P3, P4, P5>.await(): SignalArguments6<P0, P1, P2, P3, P4, P5> =
         suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments6<P0, P1, P2, P3, P4, P5>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 ->
-        cont.resume(SignalArguments6(p0, p1, p2, p3, p4, p5))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 -> cont.resume(SignalArguments6(p0, p1, p2, p3, p4, p5)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments7<P0, P1, P2, P3, P4, P5, P6>(
     public val p0: P0,
@@ -162,14 +139,11 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3, reifi
         reified P6> Signal7<P0, P1, P2, P3, P4, P5, P6>.await():
         SignalArguments7<P0, P1, P2, P3, P4, P5, P6> = suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments7<P0, P1, P2, P3, P4, P5, P6>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6 ->
-        cont.resume(SignalArguments7(p0, p1, p2, p3, p4, p5, p6))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6 -> cont.resume(SignalArguments7(p0, p1, p2, p3, p4, p5, p6)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments8<P0, P1, P2, P3, P4, P5, P6, P7>(
     public val p0: P0,
@@ -186,14 +160,11 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3, reifi
         reified P6, reified P7> Signal8<P0, P1, P2, P3, P4, P5, P6, P7>.await():
         SignalArguments8<P0, P1, P2, P3, P4, P5, P6, P7> = suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments8<P0, P1, P2, P3, P4, P5, P6, P7>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7 ->
-        cont.resume(SignalArguments8(p0, p1, p2, p3, p4, p5, p6, p7))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7 -> cont.resume(SignalArguments8(p0, p1, p2, p3, p4, p5, p6, p7)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments9<P0, P1, P2, P3, P4, P5, P6, P7, P8>(
     public val p0: P0,
@@ -211,14 +182,11 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3, reifi
         reified P6, reified P7, reified P8> Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8>.await():
         SignalArguments9<P0, P1, P2, P3, P4, P5, P6, P7, P8> = suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments9<P0, P1, P2, P3, P4, P5, P6, P7, P8>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8 ->
-        cont.resume(SignalArguments9(p0, p1, p2, p3, p4, p5, p6, p7, p8))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8 -> cont.resume(SignalArguments9(p0, p1, p2, p3, p4, p5, p6, p7, p8)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(
     public val p0: P0,
@@ -238,14 +206,11 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3, reifi
         Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>.await():
         SignalArguments10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> = suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9 ->
-        cont.resume(SignalArguments10(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9 -> cont.resume(SignalArguments10(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(
     public val p0: P0,
@@ -267,14 +232,11 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3, reifi
         SignalArguments11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> =
         suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10 ->
-        cont.resume(SignalArguments11(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10 -> cont.resume(SignalArguments11(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(
     public val p0: P0,
@@ -297,14 +259,11 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3, reifi
         SignalArguments12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> =
         suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11 ->
-        cont.resume(SignalArguments12(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11 -> cont.resume(SignalArguments12(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(
     public val p0: P0,
@@ -328,14 +287,11 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3, reifi
         SignalArguments13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> =
         suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12 ->
-        cont.resume(SignalArguments13(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12 -> cont.resume(SignalArguments13(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(
     public val p0: P0,
@@ -360,14 +316,11 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3, reifi
         SignalArguments14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> =
         suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13 ->
-        cont.resume(SignalArguments14(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13 -> cont.resume(SignalArguments14(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13,
         P14>(
@@ -395,14 +348,11 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3, reifi
         SignalArguments15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> =
         suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14 ->
-        cont.resume(SignalArguments15(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14 -> cont.resume(SignalArguments15(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) },
+    { cont.cancel() },
+    )
+}
 
 public data class SignalArguments16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14,
         P15>(
@@ -431,11 +381,8 @@ public suspend inline fun <reified P0, reified P1, reified P2, reified P3, reifi
         SignalArguments16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> =
         suspendCancellableCoroutine {
     cont: CancellableContinuation<SignalArguments16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>> ->
-    connectThreadSafe( {
-        p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15 ->
-        cont.resume(SignalArguments16(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15))
-    }
-    .asCallable {
-        cont.cancel()
-    }
-    , Object.ConnectFlags.ONE_SHOT.id.toInt())}
+    promise(
+    { p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15 -> cont.resume(SignalArguments16(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) },
+    { cont.cancel() },
+    )
+}
diff --git a/kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/GodotCoroutine.kt b/kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/GodotCoroutine.kt
index 5733b0ce8..75a796488 100644
--- a/kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/GodotCoroutine.kt
+++ b/kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/GodotCoroutine.kt
@@ -8,7 +8,7 @@ import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 
 object GodotCoroutine : CoroutineScope {
-    override val coroutineContext  = GodotDispatchers.ThreadPool + SupervisorJob()
+    override val coroutineContext = GodotDispatchers.ThreadPool + SupervisorJob()
 }
 
 fun godotCoroutine(
diff --git a/kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/GodotDispatchers.kt b/kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/GodotDispatchers.kt
index e7890efce..7c8bc34d1 100644
--- a/kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/GodotDispatchers.kt
+++ b/kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/GodotDispatchers.kt
@@ -4,11 +4,12 @@ import godot.api.Engine
 import godot.api.Object
 import godot.api.SceneTree
 import godot.api.WorkerThreadPool
-import godot.core.Callable
 import godot.core.asCallable
+import godot.internal.memory.MemoryManager
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Runnable
-import kotlinx.coroutines.cancel
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
 import kotlin.coroutines.CoroutineContext
 
 object GodotDispatchers {
@@ -20,30 +21,77 @@ object GodotDispatchers {
 
     private object GodotMainThreadCoroutineDispatcher : CoroutineDispatcher() {
         override fun dispatch(context: CoroutineContext, block: Runnable) {
-            Callable({ block.run() }.asCallable { context.cancel() }).callDeferred()
+            { block.run() }.asCallable().callDeferred()
         }
     }
 
     private object GodotThreadPoolCoroutineDispatcher : CoroutineDispatcher() {
+        private const val MIN_SIZE = 64
+
+        val lock = ReentrantLock()
+        val currentTasks = HashMap<Runnable, Long>(MIN_SIZE)
+        val terminatedTasks = ArrayList<Long>(MIN_SIZE)
+
+        init {
+            // Schedule to clear remaining tasks when Godot terminates..
+            MemoryManager.registerCallback(true, ::clearCompletedTasks)
+        }
+
         override fun dispatch(context: CoroutineContext, block: Runnable) {
-            WorkerThreadPool.addTask({ block.run() }.asCallable { context.cancel() })
+            val callable = {
+                try {
+                    block.run()
+                } finally {
+                    lock.withLock {
+                        val id = currentTasks.remove(block)!!
+                        terminatedTasks.add(id)
+                    }
+                }
+            }.asCallable()
+
+            val taskID = WorkerThreadPool.addTask(callable)
+
+            val tasksToClear = lock.withLock {
+                currentTasks[block] = taskID
+                terminatedTasks.toTypedArray().also {
+                    terminatedTasks.clear()
+                }
+            }
+
+            tasksToClear.forEach {
+                /**
+                 *  It's mandatory in Godot to call this method at some point after adding a task to clean up memory.
+                 *  We cannot wait immediately after adding the task because it would block the thread doing the dispatching, but we can do it after the task has been confirmed completed.
+                 *  It would also be wasteful to allocate a separate thread to poll and check task completions so instead we do process the list of complete tasks right after a regular dispatch.
+                 */
+                WorkerThreadPool.waitForTaskCompletion(it)
+            }
+        }
+
+
+        private fun clearCompletedTasks() {
+            // Warning, this method is only supposed to be called when Godot terminates!
+            terminatedTasks.forEach {
+                WorkerThreadPool.waitForTaskCompletion(it)
+            }
+            terminatedTasks.clear()
         }
     }
 
     private object GodotProcessFrameCoroutineDispatcher : CoroutineDispatcher() {
         override fun dispatch(context: CoroutineContext, block: Runnable) {
-            sceneTree.processFrame.connect(
-                { block.run() }.asCallable { context.cancel() },
-                Object.ConnectFlags.ONE_SHOT.id.toInt()
+            sceneTree.processFrame.connectUnsafe(
+                { block.run() }.asCallable(),
+                Object.ConnectFlags.ONE_SHOT
             )
         }
     }
 
     private object GodotPhysicsFrameCoroutineDispatcher : CoroutineDispatcher() {
         override fun dispatch(context: CoroutineContext, block: Runnable) {
-            sceneTree.physicsFrame.connect(
-                { block.run() }.asCallable { context.cancel() },
-                Object.ConnectFlags.ONE_SHOT.id.toInt()
+            sceneTree.physicsFrame.connectUnsafe(
+                { block.run() }.asCallable(),
+                Object.ConnectFlags.ONE_SHOT
             )
         }
     }
diff --git a/kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/awaitResourceLoad.kt b/kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/awaitResourceLoad.kt
index 783ed0267..443da7ea6 100644
--- a/kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/awaitResourceLoad.kt
+++ b/kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/awaitResourceLoad.kt
@@ -1,21 +1,9 @@
 package godot.coroutines
 
-import godot.core.Error
 import godot.api.Resource
 import godot.api.ResourceLoader
 import godot.api.ResourceLoader.CacheMode
-import godot.core.variantArrayOf
-import godot.global.GD
-import godot.common.util.RealT
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
 import kotlinx.coroutines.async
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlin.coroutines.resume
-import kotlin.coroutines.resumeWithException
 
 
 /**
@@ -23,17 +11,13 @@ import kotlin.coroutines.resumeWithException
  *
  * @param path The path of the resource to be loaded.
  * @param typeHint A hint about the type of resource being loaded.
- * @param useSubThreads Specifies whether to use sub-threads for loading the resource.
  * @param cacheMode The cache mode to be used while loading the resource.
- * @param onProgress A callback function to track the progress of resource loading.
  * @return The loaded resource, or null if there was an error.
  */
 public suspend inline fun ResourceLoader.awaitLoad(
     path: String,
     typeHint: String = "",
-    useSubThreads: Boolean = false,
-    cacheMode: CacheMode = ResourceLoader.CacheMode.REUSE,
-    crossinline onProgress: (RealT) -> Unit = {},
+    cacheMode: CacheMode = CacheMode.REUSE,
 ): Resource? {
     // early return in case the resource is already loaded
     if (hasCached(path)) {
@@ -41,8 +25,8 @@ public suspend inline fun ResourceLoader.awaitLoad(
     }
 
     // Start a new job so we have a suspension point in case the coroutine is currently in the main thread.
-    val job = GodotCoroutine.async(Dispatchers.Default) {
-        load(path)
+    val job = GodotCoroutine.async(GodotDispatchers.ThreadPool) {
+        load(path, typeHint, cacheMode)
     }
 
     return job.await()
@@ -53,18 +37,14 @@ public suspend inline fun ResourceLoader.awaitLoad(
  *
  * @param path The path of the resource to be loaded.
  * @param typeHint A hint about the type of resource being loaded.
- * @param useSubThreads Specifies whether to use sub-threads for loading the resource.
  * @param cacheMode The cache mode to be used while loading the resource.
- * @param onProgress A callback function to track the progress of resource loading.
  * @return The loaded resource, or null if there was an error.
  */
 public suspend inline fun <R> ResourceLoader.awaitLoadAs(
     path: String,
     typeHint: String = "",
-    useSubThreads: Boolean = false,
-    cacheMode: CacheMode = ResourceLoader.CacheMode.REUSE,
-    crossinline onProgress: (RealT) -> Unit = {},
+    cacheMode: CacheMode = CacheMode.REUSE,
 ): R? {
     @Suppress("UNCHECKED_CAST")
-    return this.awaitLoad(path, typeHint, useSubThreads, cacheMode, onProgress) as? R
+    return this.awaitLoad(path, typeHint, cacheMode) as? R
 }
diff --git a/kt/godot-library/godot-extension-library/src/main/kotlin/gen/godot/extension/SignalConnectors.kt b/kt/godot-library/godot-extension-library/src/main/kotlin/gen/godot/extension/SignalConnectors.kt
new file mode 100644
index 000000000..6ea8d09f1
--- /dev/null
+++ b/kt/godot-library/godot-extension-library/src/main/kotlin/gen/godot/extension/SignalConnectors.kt
@@ -0,0 +1,1032 @@
+@file:Suppress(
+  "PackageDirectoryMismatch", "UNCHECKED_CAST",
+  "unused",
+  "NOTHING_TO_INLINE",
+)
+
+package godot.extension
+
+import godot.api.Object
+import godot.api.Object.ConnectFlags
+import godot.core.LambdaContainer0
+import godot.core.LambdaContainer1
+import godot.core.LambdaContainer10
+import godot.core.LambdaContainer11
+import godot.core.LambdaContainer12
+import godot.core.LambdaContainer13
+import godot.core.LambdaContainer14
+import godot.core.LambdaContainer15
+import godot.core.LambdaContainer16
+import godot.core.LambdaContainer2
+import godot.core.LambdaContainer3
+import godot.core.LambdaContainer4
+import godot.core.LambdaContainer5
+import godot.core.LambdaContainer6
+import godot.core.LambdaContainer7
+import godot.core.LambdaContainer8
+import godot.core.LambdaContainer9
+import godot.core.MethodCallable
+import godot.core.Signal0
+import godot.core.Signal1
+import godot.core.Signal10
+import godot.core.Signal11
+import godot.core.Signal12
+import godot.core.Signal13
+import godot.core.Signal14
+import godot.core.Signal15
+import godot.core.Signal16
+import godot.core.Signal2
+import godot.core.Signal3
+import godot.core.Signal4
+import godot.core.Signal5
+import godot.core.Signal6
+import godot.core.Signal7
+import godot.core.Signal8
+import godot.core.Signal9
+import godot.core.VariantParser
+import godot.core.asCallable
+import godot.core.toGodotName
+import godot.core.variantMapper
+import kotlin.Suppress
+import kotlin.Unit
+import kotlin.jvm.JvmSynthetic
+import kotlin.reflect.KCallable
+
+public inline fun Signal0.connectLambda(flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+    noinline method: () -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object> Signal0.connectMethod(
+  target: T,
+  method: T.() -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun Signal0.promise(noinline method: () -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer0<Unit>(VariantParser.NIL, arrayOf(), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0> Signal1<P0>.connectLambda(flags: Object.ConnectFlags =
+    Object.ConnectFlags.DEFAULT, noinline method: (p0: P0) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0> Signal1<P0>.connectMethod(
+  target: T,
+  method: T.(p0: P0) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0> Signal1<P0>.promise(noinline method: (p0: P0) -> Unit, noinline
+    cancel: () -> Unit): Unit {
+  LambdaContainer1<Unit, P0>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1> Signal2<P0, P1>.connectLambda(flags: Object.ConnectFlags
+    = Object.ConnectFlags.DEFAULT, noinline method: (p0: P0, p1: P1) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1> Signal2<P0, P1>.connectMethod(
+  target: T,
+  method: T.(p0: P0, p1: P1) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1> Signal2<P0, P1>.promise(noinline method: (p0: P0,
+    p1: P1) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer2<Unit, P0, P1>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2>
+    Signal3<P0, P1, P2>.connectLambda(flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+    noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2> Signal3<P0, P1, P2>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2> Signal3<P0, P1, P2>.promise(noinline
+    method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer3<Unit, P0, P1, P2>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3>
+    Signal4<P0, P1, P2, P3>.connectLambda(flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+    noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3> Signal4<P0, P1, P2, P3>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3>
+    Signal4<P0, P1, P2, P3>.promise(noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer4<Unit, P0, P1, P2, P3>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4>
+    Signal5<P0, P1, P2, P3, P4>.connectLambda(flags: Object.ConnectFlags =
+    Object.ConnectFlags.DEFAULT, noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3, P4> Signal5<P0, P1, P2, P3, P4>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4>
+    Signal5<P0, P1, P2, P3, P4>.promise(noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer5<Unit, P0, P1, P2, P3, P4>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5>
+    Signal6<P0, P1, P2, P3, P4, P5>.connectLambda(flags: Object.ConnectFlags =
+    Object.ConnectFlags.DEFAULT, noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3, P4, P5> Signal6<P0, P1, P2, P3, P4, P5>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5>
+    Signal6<P0, P1, P2, P3, P4, P5>.promise(noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer6<Unit, P0, P1, P2, P3, P4, P5>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6> Signal7<P0, P1, P2, P3, P4, P5, P6>.connectLambda(flags: Object.ConnectFlags =
+    Object.ConnectFlags.DEFAULT, noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3, P4, P5, P6>
+    Signal7<P0, P1, P2, P3, P4, P5, P6>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6> Signal7<P0, P1, P2, P3, P4, P5, P6>.promise(noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer7<Unit, P0, P1, P2, P3, P4, P5, P6>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7> Signal8<P0, P1, P2, P3, P4, P5, P6, P7>.connectLambda(flags: Object.ConnectFlags
+    = Object.ConnectFlags.DEFAULT, noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3, P4, P5, P6, P7>
+    Signal8<P0, P1, P2, P3, P4, P5, P6, P7>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7> Signal8<P0, P1, P2, P3, P4, P5, P6, P7>.promise(noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer8<Unit, P0, P1, P2, P3, P4, P5, P6, P7>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8>
+    Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8>.connectLambda(flags: Object.ConnectFlags =
+    Object.ConnectFlags.DEFAULT, noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3, P4, P5, P6, P7, P8>
+    Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8> Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8>.promise(noinline
+    method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer9<Unit, P0, P1, P2, P3, P4, P5, P6, P7, P8>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9>
+    Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>.connectLambda(flags: Object.ConnectFlags =
+    Object.ConnectFlags.DEFAULT, noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>
+    Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9>
+    Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>.promise(noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer10<Unit, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9, reified P10>
+    Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>.connectLambda(flags: Object.ConnectFlags =
+    Object.ConnectFlags.DEFAULT, noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>
+    Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9, reified P10>
+    Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>.promise(noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer11<Unit, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9, reified P10, reified P11>
+    Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>.connectLambda(flags: Object.ConnectFlags
+    = Object.ConnectFlags.DEFAULT, noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>
+    Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9, reified P10, reified P11>
+    Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>.promise(noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer12<Unit, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12>
+    Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>.connectLambda(flags: Object.ConnectFlags
+    = Object.ConnectFlags.DEFAULT, noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>
+    Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12>
+    Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>.promise(noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer13<Unit, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13>
+    Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>.connectLambda(flags: Object.ConnectFlags
+    = Object.ConnectFlags.DEFAULT, noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>
+    Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13>
+    Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>.promise(noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer14<Unit, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
+    reified P14>
+    Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>.connectLambda(flags: Object.ConnectFlags
+    = Object.ConnectFlags.DEFAULT, noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+  p14: P14,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>
+    Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
+    reified P14>
+    Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>.promise(noinline
+    method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+  p14: P14,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer15<Unit, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!, variantMapper[P14::class]!!), method).setAsCancellable(this, cancel)
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
+    reified P14, reified P15>
+    Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>.connectLambda(flags: Object.ConnectFlags
+    = Object.ConnectFlags.DEFAULT, noinline method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+  p14: P14,
+  p15: P15,
+) -> Unit): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      method.asCallable()
+  )
+  connector.connect(flags)
+  return connector
+}
+
+@JvmSynthetic
+public fun <T : Object, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>
+    Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>.connectMethod(
+  target: T,
+  method: T.(
+    p0: P0,
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+    p7: P7,
+    p8: P8,
+    p9: P9,
+    p10: P10,
+    p11: P11,
+    p12: P12,
+    p13: P13,
+    p14: P14,
+    p15: P15,
+  ) -> Unit,
+  flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT,
+): SignalConnector {
+  val connector = SignalConnector.createUnsafe(
+      this, 
+      MethodCallable(target, (method as KCallable<*>).name.toGodotName())
+  )
+  connector.connect(flags)
+  return connector
+}
+
+public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
+    P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
+    reified P14, reified P15>
+    Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>.promise(noinline
+    method: (
+  p0: P0,
+  p1: P1,
+  p2: P2,
+  p3: P3,
+  p4: P4,
+  p5: P5,
+  p6: P6,
+  p7: P7,
+  p8: P8,
+  p9: P9,
+  p10: P10,
+  p11: P11,
+  p12: P12,
+  p13: P13,
+  p14: P14,
+  p15: P15,
+) -> Unit, noinline cancel: () -> Unit): Unit {
+  LambdaContainer16<Unit, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>(VariantParser.NIL, arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!, variantMapper[P14::class]!!, variantMapper[P15::class]!!), method).setAsCancellable(this, cancel)
+}
diff --git a/kt/godot-library/godot-extension-library/src/main/kotlin/gen/godot/extension/SignalUtils.kt b/kt/godot-library/godot-extension-library/src/main/kotlin/gen/godot/extension/SignalUtils.kt
deleted file mode 100644
index 5a938290d..000000000
--- a/kt/godot-library/godot-extension-library/src/main/kotlin/gen/godot/extension/SignalUtils.kt
+++ /dev/null
@@ -1,512 +0,0 @@
-@file:Suppress(
-    "PackageDirectoryMismatch",
-    "NOTHING_TO_INLINE",
-    "UNUSED_PARAMETER",
-)
-
-package godot.extension
-
-import godot.api.Object
-import godot.core.Callable
-import godot.core.Signal0
-import godot.core.Signal1
-import godot.core.Signal10
-import godot.core.Signal11
-import godot.core.Signal12
-import godot.core.Signal13
-import godot.core.Signal14
-import godot.core.Signal15
-import godot.core.Signal16
-import godot.core.Signal2
-import godot.core.Signal3
-import godot.core.Signal4
-import godot.core.Signal5
-import godot.core.Signal6
-import godot.core.Signal7
-import godot.core.Signal8
-import godot.core.Signal9
-import godot.core.asCallable
-import godot.core.toGodotName
-import godot.extension.connectThreadSafe
-import kotlin.Any
-import kotlin.Int
-import kotlin.Suppress
-import kotlin.Unit
-import kotlin.reflect.KCallable
-
-public fun <T : Object> Signal0.connectThreadSafe(
-    target: T,
-    method: T.() -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun Signal0.connectThreadSafe(flags: Int = 0, noinline method: () -> Unit): Any? =
-        connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, T : Object> Signal1<P0>.connectThreadSafe(
-    target: T,
-    method: T.(p0: P0) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0> Signal1<P0>.connectThreadSafe(flags: Int = 0, noinline
-        method: (p0: P0) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, T : Object> Signal2<P0, P1>.connectThreadSafe(
-    target: T,
-    method: T.(p0: P0, p1: P1) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1> Signal2<P0, P1>.connectThreadSafe(flags: Int = 0,
-        noinline method: (p0: P0, p1: P1) -> Unit): Any? =
-        connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, T : Object> Signal3<P0, P1, P2>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2>
-        Signal3<P0, P1, P2>.connectThreadSafe(flags: Int = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, T : Object> Signal4<P0, P1, P2, P3>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3>
-        Signal4<P0, P1, P2, P3>.connectThreadSafe(flags: Int = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, P4, T : Object> Signal5<P0, P1, P2, P3, P4>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4>
-        Signal5<P0, P1, P2, P3, P4>.connectThreadSafe(flags: Int = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, P4, P5, T : Object> Signal6<P0, P1, P2, P3, P4, P5>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5>
-        Signal6<P0, P1, P2, P3, P4, P5>.connectThreadSafe(flags: Int = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, P4, P5, P6, T : Object>
-        Signal7<P0, P1, P2, P3, P4, P5, P6>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6> Signal7<P0, P1, P2, P3, P4, P5, P6>.connectThreadSafe(flags: Int = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, P4, P5, P6, P7, T : Object>
-        Signal8<P0, P1, P2, P3, P4, P5, P6, P7>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7> Signal8<P0, P1, P2, P3, P4, P5, P6, P7>.connectThreadSafe(flags: Int = 0,
-        noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, T : Object>
-        Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8>
-        Signal9<P0, P1, P2, P3, P4, P5, P6, P7, P8>.connectThreadSafe(flags: Int = 0, noinline
-        method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, T : Object>
-        Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9>
-        Signal10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>.connectThreadSafe(flags: Int = 0, noinline
-        method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, T : Object>
-        Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9, reified P10>
-        Signal11<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>.connectThreadSafe(flags: Int = 0,
-        noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-    p10: P10,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, T : Object>
-        Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9, reified P10, reified P11>
-        Signal12<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>.connectThreadSafe(flags: Int = 0,
-        noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-    p10: P10,
-    p11: P11,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, T : Object>
-        Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-        p12: P12,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12>
-        Signal13<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>.connectThreadSafe(flags: Int
-        = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-    p10: P10,
-    p11: P11,
-    p12: P12,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, T : Object>
-        Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-        p12: P12,
-        p13: P13,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13>
-        Signal14<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>.connectThreadSafe(flags: Int
-        = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-    p10: P10,
-    p11: P11,
-    p12: P12,
-    p13: P13,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, T : Object>
-        Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-        p12: P12,
-        p13: P13,
-        p14: P14,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
-        reified P14>
-        Signal15<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>.connectThreadSafe(flags: Int
-        = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-    p10: P10,
-    p11: P11,
-    p12: P12,
-    p13: P13,
-    p14: P14,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
-
-public fun <P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, T : Object>
-        Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>.connectThreadSafe(
-    target: T,
-    method: T.(
-        p0: P0,
-        p1: P1,
-        p2: P2,
-        p3: P3,
-        p4: P4,
-        p5: P5,
-        p6: P6,
-        p7: P7,
-        p8: P8,
-        p9: P9,
-        p10: P10,
-        p11: P11,
-        p12: P12,
-        p13: P13,
-        p14: P14,
-        p15: P15,
-    ) -> Unit,
-    flags: Int = 0,
-): Any? = connectThreadSafe(Callable(target, (method as KCallable<*>).name.toGodotName()), flags)
-
-public inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified
-        P6, reified P7, reified P8, reified P9, reified P10, reified P11, reified P12, reified P13,
-        reified P14, reified P15>
-        Signal16<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>.connectThreadSafe(flags: Int
-        = 0, noinline method: (
-    p0: P0,
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-    p7: P7,
-    p8: P8,
-    p9: P9,
-    p10: P10,
-    p11: P11,
-    p12: P12,
-    p13: P13,
-    p14: P14,
-    p15: P15,
-) -> Unit): Any? = connectThreadSafe(method.asCallable(), flags)
diff --git a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/ObjectExt.kt b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/ObjectExt.kt
deleted file mode 100644
index ab4800fb3..000000000
--- a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/ObjectExt.kt
+++ /dev/null
@@ -1,153 +0,0 @@
-@file:JvmName("ObjectUtils")
-
-package godot.extension
-
-import godot.api.Object
-import godot.api.RefCounted
-import godot.core.Callable
-import godot.core.VariantArray
-import godot.internal.memory.MemoryManager
-import godot.core.Signal
-import godot.core.asCachedStringName
-import godot.core.toGodotName
-import kotlin.reflect.KFunction
-
-/**
- * **Note:** The function name is converted to snake_case
- * Use [Object.callDeferred] to call functions by string or [callDeferredRawName] for an unconverted version of this function
- */
-inline fun <reified T : KFunction<*>> Object.callDeferred(function: T, vararg args: Any?) =
-    callDeferred(function.name.toGodotName(), *args)
-
-/**
- * Same as [callDeferred] but the function name is not converted to snake_case
- */
-inline fun <reified T : KFunction<*>> Object.callDeferredRawName(function: T, vararg args: Any?) =
-    callDeferred(function.name.asCachedStringName(), *args)
-
-/**
- * **Note:** The function name is converted to snake_case
- * Use [Object.call] to call functions by string or [callRawName] for an unconverted version of this function
- */
-inline fun <reified T : KFunction<*>> Object.call(function: T, vararg args: Any?) =
-    call(function.name.toGodotName(), *args)
-
-/**
- * Same as [call] but the function name is not converted to snake_case
- */
-inline fun <reified T : KFunction<*>> Object.callRawName(function: T, vararg args: Any?) =
-    call(function.name.asCachedStringName(), *args)
-
-/**
- * **Note:** The function name is converted to snake_case
- * Use [Object.callv] to call functions by string or [callvRawName] for an unconverted version of this function
- */
-inline fun <reified T : KFunction<*>> Object.callv(function: T, argArray: VariantArray<Any?>) =
-    callv(function.name.toGodotName(), argArray)
-
-/**
- * Same as [callv] but the function name is not converted to snake_case
- */
-inline fun <reified T : KFunction<*>> Object.callvRawName(function: T, argArray: VariantArray<Any?>) =
-    callv(function.name.asCachedStringName(), argArray)
-
-/**
- * **Note:** The function name is converted to snake_case
- * Use [Object.hasMethod] to check function existence by string or [hasMethodRawName] for an unconverted version of this function
- */
-inline fun <reified T : KFunction<*>> Object.hasMethod(function: T) =
-    hasMethod(function.name.toGodotName())
-
-/**
- * Same as [hasMethod] but the function name is not converted to snake_case
- */
-inline fun <reified T : KFunction<*>> Object.hasMethodRawName(function: T) =
-    hasMethod(function.name.asCachedStringName())
-
-/**
- * **Note:** The function name is converted to snake_case
- * Use [Object.isConnected] to check connections by string or [hasMethodRawName] for an unconverted version of this function
- */
-//TODO/4.0: Check if still correct
-inline fun <reified T : KFunction<*>> Object.isConnected(
-    signal: Signal,
-    target: Object,
-    function: T
-) = isConnected(signal.name, Callable(target, function.name.toGodotName()))
-
-/**
- * Same as [isConnected] but the function name is not converted to snake_case
- */
-//TODO/4.0: Check if still correct
-inline fun <reified T : KFunction<*>> Object.isConnectedRawName(
-    signal: Signal,
-    target: Object,
-    function: T
-) = isConnected(signal.name, Callable(target, function.name.asCachedStringName()))
-
-/**
- * **Note:** The function name is converted to snake_case
- * Use [Object.connect] to connect by string or [hasMethodRawName] for an unconverted version of this function
- */
-//TODO/4.0: Check if still correct
-inline fun <reified T : KFunction<*>> Object.connect(
-    signal: Signal,
-    target: Object,
-    function: T,
-    flags: Int = 0
-) = connect(
-    signal.name,
-    Callable(target, function.name.toGodotName()),
-    flags.toLong()
-)
-
-/**
- * Same as [connect] but the function name is not converted to snake_case
- */
-//TODO/4.0: Check if still correct
-inline fun <reified T : KFunction<*>> Object.connectRawName(
-    signal: Signal,
-    target: Object,
-    function: T,
-    flags: Int = 0
-) = connect(signal.name, Callable(target, function.name.asCachedStringName()), flags.toLong())
-
-/**
- * **Note:** The function name is converted to snake_case
- * Use [Object.disconnect] to connect by string or [disconnectRawName] for an unconverted version of this function
- */
-//TODO/4.0: Check if still correct
-inline fun <reified T : KFunction<*>> Object.disconnect(
-    signal: Signal,
-    target: Object,
-    function: T
-) = disconnect(signal.name, Callable(target, function.name.toGodotName()))
-
-/**
- * Same as [disconnect] but the function name is not converted to snake_case
- */
-//TODO/4.0: Check if still correct
-inline fun <reified T : KFunction<*>> Object.disconnectRawName(
-    signal: Signal,
-    target: Object,
-    function: T
-) = disconnect(signal.name, Callable(target, function.name.asCachedStringName()))
-
-
-/**
- * Instance will be automatically freed when the engine closes.
- */
-fun <T : Object?> T.asStatic(): T {
-    if (this == null || this is RefCounted) {
-        return this
-    }
-    MemoryManager.registerCallback {
-        if (!MemoryManager.isInstanceValid(this)) {
-            return@registerCallback
-        }
-        free()
-
-    }
-    return this
-}
-
diff --git a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/SignalExt.kt b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/SignalExt.kt
deleted file mode 100644
index b2ba8e08f..000000000
--- a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/SignalExt.kt
+++ /dev/null
@@ -1,21 +0,0 @@
-package godot.extension
-
-import godot.core.Callable
-import godot.core.Signal
-import godot.api.Node
-import godot.core.asStringName
-
-private val connectMethodName = "connect".asStringName()
-
-fun Signal.connectThreadSafe(callable: Callable, flags: Int = 0) =
-    (godotObject as? Node)?.callThreadSafe(
-        connectMethodName,
-        name,
-        callable,
-        flags.toLong()
-    ) ?: godotObject.connect(
-        name,
-        callable,
-        flags.toLong()
-    )
-
diff --git a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/NodeExt.kt b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/api/NodeExt.kt
similarity index 94%
rename from kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/NodeExt.kt
rename to kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/api/NodeExt.kt
index 301fa1a5a..837935416 100644
--- a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/NodeExt.kt
+++ b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/api/NodeExt.kt
@@ -1,5 +1,6 @@
 @file:JvmName("NodeUtils")
-package godot.extension
+
+package godot.extension.api
 
 import godot.api.Node
 import godot.core.NodePath
diff --git a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/api/ObjectExt.kt b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/api/ObjectExt.kt
new file mode 100644
index 000000000..b7fe48f8c
--- /dev/null
+++ b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/api/ObjectExt.kt
@@ -0,0 +1,41 @@
+@file:JvmName("ObjectUtils")
+
+package godot.extension.api
+
+import godot.api.Object
+import godot.api.RefCounted
+import godot.internal.memory.MemoryManager
+import godot.core.asCachedStringName
+import godot.core.toGodotName
+import kotlin.reflect.KFunction
+
+/**
+ * **Note:** The function name is converted to snake_case
+ * Use [Object.hasMethod] to check function existence by string or [hasMethodRawName] for an unconverted version of this function
+ */
+inline fun <reified T : KFunction<*>> Object.hasMethod(function: T) =
+    hasMethod(function.name.toGodotName())
+
+/**
+ * Same as [hasMethod] but the function name is not converted to snake_case
+ */
+inline fun <reified T : KFunction<*>> Object.hasMethodRawName(function: T) =
+    hasMethod(function.name.asCachedStringName())
+
+/**
+ * Instance will be automatically freed when the engine closes.
+ */
+fun <T : Object?> T.asStatic(): T {
+    if (this == null || this is RefCounted) {
+        return this
+    }
+    MemoryManager.registerCallback {
+        if (!MemoryManager.isInstanceValid(this)) {
+            return@registerCallback
+        }
+        free()
+
+    }
+    return this
+}
+
diff --git a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/PackedSceneExt.kt b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/api/PackedSceneExt.kt
similarity index 91%
rename from kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/PackedSceneExt.kt
rename to kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/api/PackedSceneExt.kt
index 5131994ea..204b36c8c 100644
--- a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/PackedSceneExt.kt
+++ b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/api/PackedSceneExt.kt
@@ -1,5 +1,6 @@
 @file:JvmName("PackedSceneUtils")
-package godot.extension
+
+package godot.extension.api
 
 import godot.api.Node
 import godot.api.PackedScene
diff --git a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/ResourceLoaderExt.kt b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/api/ResourceLoaderExt.kt
similarity index 92%
rename from kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/ResourceLoaderExt.kt
rename to kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/api/ResourceLoaderExt.kt
index 3753536ca..5f9ca8108 100644
--- a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/ResourceLoaderExt.kt
+++ b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/api/ResourceLoaderExt.kt
@@ -1,5 +1,6 @@
 @file:JvmName("ResourceLoaderUtils")
-package godot.extension
+
+package godot.extension.api
 
 import godot.api.Resource
 import godot.api.ResourceLoader
diff --git a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/callback/SignalConnector.kt b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/callback/SignalConnector.kt
new file mode 100644
index 000000000..2393ca2ca
--- /dev/null
+++ b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/extension/callback/SignalConnector.kt
@@ -0,0 +1,23 @@
+@file:Suppress("PackageDirectoryMismatch", "unused")
+
+package godot.extension
+
+import godot.api.Object.ConnectFlags
+import godot.core.Callable
+import godot.core.Signal
+import godot.core.Error
+
+class SignalConnector internal constructor(
+    private val signal: Signal,
+    private val callable: Callable,
+) {
+    fun connect(flags: ConnectFlags = ConnectFlags.DEFAULT): Error = signal.connectUnsafe(callable, flags)
+    fun disconnect(): Unit = signal.disconnectUnsafe(callable)
+    fun isConnected(): Boolean = signal.isConnected(callable)
+    fun isValid(): Boolean = signal.isValid() && callable.isValid()
+
+    companion object {
+        @JvmStatic
+        fun createUnsafe(signal: Signal, callable: Callable,) = SignalConnector(signal, callable)
+    }
+}
diff --git a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/global/GD.kt b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/global/GD.kt
index 19f60ca74..21092aa6a 100644
--- a/kt/godot-library/godot-extension-library/src/main/kotlin/godot/global/GD.kt
+++ b/kt/godot-library/godot-extension-library/src/main/kotlin/godot/global/GD.kt
@@ -13,8 +13,8 @@ import godot.core.PackedStringArray
 import godot.core.PackedVector2Array
 import godot.core.PackedVector3Array
 import godot.internal.memory.MemoryManager
-import godot.extension.asStatic
-import godot.extension.loadAs
+import godot.extension.api.asStatic
+import godot.extension.api.loadAs
 import godot.common.interop.nullptr
 
 
diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/ParametersReader.kt b/kt/godot-library/godot-internal-library/src/main/kotlin/godot/internal/memory/ParametersReader.kt
similarity index 58%
rename from kt/godot-library/godot-core-library/src/main/kotlin/godot/core/ParametersReader.kt
rename to kt/godot-library/godot-internal-library/src/main/kotlin/godot/internal/memory/ParametersReader.kt
index 008162617..56f4a3a11 100644
--- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/ParametersReader.kt
+++ b/kt/godot-library/godot-internal-library/src/main/kotlin/godot/internal/memory/ParametersReader.kt
@@ -1,35 +1,29 @@
-package godot.core
+package godot.internal.memory
 
-import godot.internal.memory.TransferContext
 import godot.common.constants.Constraints
 import godot.common.interop.VariantConverter
 import godot.common.util.threadLocal
 
-internal open class ParametersReader {
+open class ParametersReader {
     val paramsArray by threadLocal {
         Array<Any?>(Constraints.MAX_FUNCTION_ARG_COUNT) {
             null
         }
     }
 
-    private fun resetParamsArray() {
-        paramsArray.fill(null)
-    }
-
-    internal inline fun withParameters(types: Array<VariantConverter>, code: () -> Unit) {
+    inline fun withParameters(types: Array<VariantConverter>, code: () -> Unit) {
         TransferContext.readArguments(types, paramsArray)
         code()
-        resetParamsArray()
+        paramsArray.fill(null, 0, types.size)
     }
 
-    internal inline fun <R> withParametersReturn(
+    inline fun <R> withParametersReturn(
         types: Array<VariantConverter>,
         code: () -> R
     ): Any? {
         TransferContext.readArguments(types, paramsArray)
         val ret = code()
-        resetParamsArray()
+        paramsArray.fill(null, 0, types.size)
         return ret
     }
 }
-
diff --git a/kt/plugins/godot-gradle-plugin/src/main/resources/godot/gradle/godot-kotlin-graal-jni-config.json b/kt/plugins/godot-gradle-plugin/src/main/resources/godot/gradle/godot-kotlin-graal-jni-config.json
index 0c528df69..4e1426e79 100644
--- a/kt/plugins/godot-gradle-plugin/src/main/resources/godot/gradle/godot-kotlin-graal-jni-config.json
+++ b/kt/plugins/godot-gradle-plugin/src/main/resources/godot/gradle/godot-kotlin-graal-jni-config.json
@@ -157,15 +157,16 @@
     ]
   },
   {
-    "name" : "godot.core.NativeCallable$Bridge",
+    "name" : "godot.core.Callable$Bridge",
     "fields" : [
       { "name" : "INSTANCE" }
     ],
     "methods" : [
       { "name" : "engine_call_constructor", "parameterTypes" : [] },
 
-      { "name" : "engine_call_constructor_object_string_name", "parameterTypes" : [] },
-      { "name" : "engine_call_constructor_kt_custom_callable", "parameterTypes" : ["godot.core.LambdaCallable", "int", "int", "boolean"] },
+      { "name" : "engine_call_constructor_object_string_name", "parameterTypes" : ["long", "long"] },
+      { "name" : "engine_call_constructor_lambda_callable", "parameterTypes" : ["godot.core.LambdaContainer", "int", "int"] },
+      { "name" : "engine_call_constructor_cancellable", "parameterTypes" : ["godot.core.LambdaContainer", "int", "int"] },
       { "name" : "engine_call_copy_constructor", "parameterTypes" : [] },
 
       { "name" : "engine_call_bind", "parameterTypes" : ["long"] },
@@ -189,12 +190,11 @@
     ]
   },
   {
-    "name" : "godot.core.LambdaCallable$Bridge",
-    "fields" : [
-      { "name" : "INSTANCE" }
-    ],
-    "methods" : [
-      { "name" : "wrap_in_custom_callable", "parameterTypes" : ["godot.core.LambdaCallable", "int", "int", "boolean"] }
+    "name":"godot.core.LambdaContainer",
+    "methods":[
+      {"name":"invoke","parameterTypes":[] },
+      {"name":"invokeWithReturn","parameterTypes":[] },
+      {"name":"cancel","parameterTypes":[] }
     ]
   },
   {
@@ -331,7 +331,10 @@
       { "name" : "engine_call_to_float64_array", "parameterTypes" : ["long"] },
       { "name" : "engine_call_to_int32_array", "parameterTypes" : ["long"] },
       { "name" : "engine_call_to_int64_array", "parameterTypes" : ["long"] },
-      { "name" : "engine_call_size", "parameterTypes" : ["long"] }
+      { "name" : "engine_call_size", "parameterTypes" : ["long"] },
+
+      { "name" : "engine_convert_to_godot", "parameterTypes" : ["byte[]"] },
+      { "name" : "engine_convert_to_jvm", "parameterTypes" : ["long"] }
     ]
   },
   {
@@ -399,7 +402,10 @@
       { "name" : "engine_call_size", "parameterTypes" : ["long"] },
       { "name" : "engine_call_slice", "parameterTypes" : ["long"] },
       { "name" : "engine_call_sort", "parameterTypes" : ["long"] },
-      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] }
+      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] },
+
+      { "name" : "engine_convert_to_godot", "parameterTypes" : ["float[]"] },
+      { "name" : "engine_convert_to_jvm", "parameterTypes" : ["long"] }
     ]
   },
   {
@@ -433,7 +439,10 @@
       { "name" : "engine_call_size", "parameterTypes" : ["long"] },
       { "name" : "engine_call_slice", "parameterTypes" : ["long"] },
       { "name" : "engine_call_sort", "parameterTypes" : ["long"] },
-      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] }
+      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] },
+
+      { "name" : "engine_convert_to_godot", "parameterTypes" : ["double[]"] },
+      { "name" : "engine_convert_to_jvm", "parameterTypes" : ["long"] }
     ]
   },
   {
@@ -467,7 +476,10 @@
       { "name" : "engine_call_size", "parameterTypes" : ["long"] },
       { "name" : "engine_call_slice", "parameterTypes" : ["long"] },
       { "name" : "engine_call_sort", "parameterTypes" : ["long"] },
-      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] }
+      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] },
+
+      { "name" : "engine_convert_to_godot", "parameterTypes" : ["int[]"] },
+      { "name" : "engine_convert_to_jvm", "parameterTypes" : ["long"] }
     ]
   },
   {
@@ -501,7 +513,10 @@
       { "name" : "engine_call_size", "parameterTypes" : ["long"] },
       { "name" : "engine_call_slice", "parameterTypes" : ["long"] },
       { "name" : "engine_call_sort", "parameterTypes" : ["long"] },
-      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] }
+      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] },
+
+      { "name" : "engine_convert_to_godot", "parameterTypes" : ["long[]"] },
+      { "name" : "engine_convert_to_jvm", "parameterTypes" : ["long"] }
     ]
   },
   {
@@ -569,7 +584,10 @@
       { "name" : "engine_call_size", "parameterTypes" : ["long"] },
       { "name" : "engine_call_slice", "parameterTypes" : ["long"] },
       { "name" : "engine_call_sort", "parameterTypes" : ["long"] },
-      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] }
+      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] },
+
+      { "name" : "engine_convert_to_godot", "parameterTypes" : ["float[]"] },
+      { "name" : "engine_convert_to_jvm", "parameterTypes" : ["long"] }
     ]
   },
   {
@@ -603,7 +621,10 @@
       { "name" : "engine_call_size", "parameterTypes" : ["long"] },
       { "name" : "engine_call_slice", "parameterTypes" : ["long"] },
       { "name" : "engine_call_sort", "parameterTypes" : ["long"] },
-      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] }
+      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] },
+
+      { "name" : "engine_convert_to_godot", "parameterTypes" : ["float[]"] },
+      { "name" : "engine_convert_to_jvm", "parameterTypes" : ["long"] }
     ]
   },
   {
@@ -637,7 +658,10 @@
       { "name" : "engine_call_size", "parameterTypes" : ["long"] },
       { "name" : "engine_call_slice", "parameterTypes" : ["long"] },
       { "name" : "engine_call_sort", "parameterTypes" : ["long"] },
-      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] }
+      { "name" : "engine_call_to_byte_array", "parameterTypes" : ["long"] },
+
+      { "name" : "engine_convert_to_godot", "parameterTypes" : ["float[]"] },
+      { "name" : "engine_convert_to_jvm", "parameterTypes" : ["long"] }
     ]
   },
   {
@@ -710,16 +734,6 @@
       {"name": "construct", "parameterTypes": ["long", "long"]}
     ]
   },
-  {
-    "name":"godot.core.LambdaCallable",
-    "methods":[
-      {"name":"invokeNoReturn","parameterTypes":[] },
-      {"name":"invokeWithReturn","parameterTypes":[] },
-      {"name":"getReturnVariantType","parameterTypes":[] },
-      {"name":"hashCode","parameterTypes":[] },
-      {"name":"onCancel","parameterTypes":[] }
-    ]
-  },
   {
     "name":"godot.core.KtFunction",
     "methods":[
diff --git a/kt/tools-common/src/main/kotlin/godot/tools/common/constants/Classes.kt b/kt/tools-common/src/main/kotlin/godot/tools/common/constants/Classes.kt
index dfc673ec6..85fbe6101 100644
--- a/kt/tools-common/src/main/kotlin/godot/tools/common/constants/Classes.kt
+++ b/kt/tools-common/src/main/kotlin/godot/tools/common/constants/Classes.kt
@@ -13,9 +13,11 @@ object GodotKotlinJvmTypes {
     const val stringName = "StringName"
     const val array = "VariantArray"
     const val callable = "Callable"
-    const val callableBase = "Callable"
+    const val methodCallable = "MethodCallable"
+    const val lambdaCallable = "LambdaCallable"
     const val dictionary = "Dictionary"
     const val error = "Error"
+    const val connector = "SignalConnector"
     const val nodePath = "NodePath"
     const val variant = "Any"
     const val refCounted = "RefCounted"
@@ -244,13 +246,16 @@ object GodotTypes {
     )
 }
 
+val GODOT_SIGNAL_CONNECTOR = ClassName(godotExtensionPackage, GodotKotlinJvmTypes.connector)
 val GODOT_ERROR = ClassName(godotCorePackage, GodotKotlinJvmTypes.error)
 val GODOT_ARRAY = ClassName(godotCorePackage, GodotKotlinJvmTypes.array)
 val GODOT_CALLABLE = ClassName(godotCorePackage, GodotKotlinJvmTypes.callable)
-val GODOT_CALLABLE_BASE = ClassName(godotCorePackage, GodotKotlinJvmTypes.callableBase)
+val GODOT_METHOD_CALLABLE = ClassName(godotCorePackage, GodotKotlinJvmTypes.methodCallable)
+val GODOT_LAMBDA_CALLABLE = ClassName(godotCorePackage, GodotKotlinJvmTypes.lambdaCallable)
 val GODOT_DICTIONARY = ClassName(godotCorePackage, GodotKotlinJvmTypes.dictionary)
 val GODOT_OBJECT = ClassName(godotApiPackage, GodotKotlinJvmTypes.obj)
 val KT_OBJECT = ClassName(godotCorePackage, GodotKotlinJvmTypes.ktObject)
+val STRING_NAME = ClassName(godotCorePackage, GodotKotlinJvmTypes.stringName)
 
 val VARIANT_PARSER_NIL = ClassName(variantParserPackage, "NIL")
 val VARIANT_PARSER_BOOL = ClassName(variantParserPackage, "BOOL")
diff --git a/register_types.cpp b/register_types.cpp
index c80744783..befdee1ca 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -94,6 +94,4 @@ void uninitialize_kotlin_jvm_module(ModuleInitializationLevel p_level) {
     JvmLanguage* jvm_language {GdjLanguage::get_instance()};
     ScriptServer::unregister_language(jvm_language);
     memdelete(jvm_language);
-
-    JvmScriptManager::finalize();
 }
diff --git a/src/gd_kotlin.cpp b/src/gd_kotlin.cpp
index 00625d173..11bf97d8d 100644
--- a/src/gd_kotlin.cpp
+++ b/src/gd_kotlin.cpp
@@ -336,6 +336,7 @@ void GDKotlin::finalize_core_library() {
 
     MemoryManager::get_instance().clean_up(env);
 
+    JvmScriptManager::finalize();
     JvmManager::finalize_jvm_wrappers(env, bootstrap_class_loader);
 
     memdelete(callable_middleman);
diff --git a/src/jni/types.cpp b/src/jni/types.cpp
index 8bc9c2a7e..333cd95b4 100644
--- a/src/jni/types.cpp
+++ b/src/jni/types.cpp
@@ -60,7 +60,6 @@ namespace jni {
         return obj == nullptr;
     }
 
-
     bool JObject::is_same_object(Env& env, const JObject& other) const {
         return env.is_same_object(obj, other.obj);
     }
@@ -142,27 +141,27 @@ namespace jni {
         return JObject(ret);
     }
 
-    JByteArray::JByteArray(Env& env, const jsize size) : JArray() {
+    JByteArray::JByteArray(Env& env, const jsize size) {
         // Allocate an Array with reserved size;
         obj = env.env->NewByteArray(size);
     }
 
-    JIntArray::JIntArray(Env& env, const jsize size) : JArray() {
+    JIntArray::JIntArray(Env& env, const jsize size) {
         // Allocate an Array with reserved size;
         obj = env.env->NewIntArray(size);
     }
 
-    JLongArray::JLongArray(Env& env, const jsize size) : JArray() {
+    JLongArray::JLongArray(Env& env, const jsize size) {
         // Allocate an Array with reserved size;
         obj = env.env->NewLongArray(size);
     }
 
-    JFloatArray::JFloatArray(Env& env, const jsize size) : JArray() {
+    JFloatArray::JFloatArray(Env& env, const jsize size) {
         // Allocate an Array with reserved size;
         obj = env.env->NewFloatArray(size);
     }
 
-    JDoubleArray::JDoubleArray(Env& env, const jsize size) : JArray() {
+    JDoubleArray::JDoubleArray(Env& env, const jsize size) {
         // Allocate an Array with reserved size;
         obj = env.env->NewDoubleArray(size);
     }
diff --git a/src/jni/types.h b/src/jni/types.h
index 8339206a5..3130d61fa 100644
--- a/src/jni/types.h
+++ b/src/jni/types.h
@@ -13,7 +13,7 @@ namespace jni {
 
     class JValue {
     public:
-        jvalue value;
+        jvalue value{};
 
         JValue(JObject obj);
 
diff --git a/src/jvm_wrapper/bridge/callable_bridge.cpp b/src/jvm_wrapper/bridge/callable_bridge.cpp
index e9b0d1e6d..7137f0d83 100644
--- a/src/jvm_wrapper/bridge/callable_bridge.cpp
+++ b/src/jvm_wrapper/bridge/callable_bridge.cpp
@@ -4,7 +4,8 @@
 #include "constraints.h"
 #include "jvm_wrapper/kotlin_callable_custom.h"
 #include "jvm_wrapper/memory/transfer_context.h"
-#include "variant_allocator.h"
+
+#include <scene/main/node.h>
 
 using namespace bridges;
 
@@ -12,21 +13,36 @@ uintptr_t CallableBridge::engine_call_constructor(JNIEnv* p_raw_env, jobject p_i
     return reinterpret_cast<uintptr_t>(VariantAllocator::alloc(Callable()));
 }
 
-uintptr_t CallableBridge::engine_call_constructor_object_string_name(JNIEnv* p_raw_env, jobject p_instance) {
+uintptr_t CallableBridge::engine_call_constructor_object_string_name(JNIEnv * p_raw_env, jobject p_instance, jlong object_ptr, jlong method_name_ptr) {
+    Object* obj = reinterpret_cast<Object*>(object_ptr);
+    StringName* name = reinterpret_cast<StringName*>(method_name_ptr);
+    return reinterpret_cast<uintptr_t>(VariantAllocator::alloc(Callable(obj, *name)));
+}
+
+uintptr_t CallableBridge::engine_call_constructor_lambda_callable(JNIEnv* p_raw_env, jobject, jobject p_lambda_container, jint p_variant_type_ordinal, jint p_hash_code) {
     jni::Env env {p_raw_env};
-    Variant args[2] = {};
-    TransferContext::get_instance().read_args(env, args);
-    return reinterpret_cast<uintptr_t>(VariantAllocator::alloc(Callable(args[0].operator Object*(), args[1].operator StringName())));
+    return reinterpret_cast<uintptr_t>(VariantAllocator::alloc(Callable(
+      memnew(JvmCallableCustom(env, p_lambda_container, static_cast<Variant::Type>(p_variant_type_ordinal), p_hash_code, false))
+    )));
 }
 
-uintptr_t CallableBridge::engine_call_constructor_kt_custom_callable(JNIEnv* p_raw_env, jobject p_instance,
-                                                                     jobject p_kt_custom_callable_instance,
-                                                                     jint p_variant_type_ordinal, jint p_hash_code,
-                                                                     jboolean p_has_on_destroy) {
+void CallableBridge::engine_call_constructor_cancellable(JNIEnv* p_raw_env, jobject p_instance, jobject p_kt_custom_callable_instance, jint p_variant_type_ordinal, jint p_hash_code) {
     jni::Env env {p_raw_env};
-    return reinterpret_cast<uintptr_t>(
-        VariantAllocator::alloc(Callable(memnew(KotlinCallableCustom(env, p_kt_custom_callable_instance, static_cast<Variant::Type>(p_variant_type_ordinal), p_hash_code, p_has_on_destroy))))
-    );
+
+    Variant args[1] = {};
+    TransferContext::get_instance().read_args(env, args);
+    Signal signal = args[0].operator Signal();
+    Callable callable {memnew(
+      JvmCallableCustom(env, p_kt_custom_callable_instance, static_cast<Variant::Type>(p_variant_type_ordinal), p_hash_code, true)
+    )};
+
+    Object* object = signal.get_object();
+    if(Node* node = Object::cast_to<Node>(object)) {
+        // Nodes can only connect their signal in the main thread.
+        node->call_thread_safe(SNAME("connect"), callable, Object::CONNECT_ONE_SHOT);
+    } else {
+        signal.connect(callable, Object::CONNECT_ONE_SHOT);
+    }
 }
 
 uintptr_t CallableBridge::engine_call_copy_constructor(JNIEnv* p_raw_env, jobject p_instance) {
@@ -51,16 +67,7 @@ void CallableBridge::engine_call_bind(JNIEnv* p_raw_env, jobject p_instance, jlo
     TransferContext::get_instance().write_return_value(env, result);
 }
 
-void CallableBridge::engine_call_bindv(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr) {
-    jni::Env env {p_raw_env};
-    Variant args[1] = {};
-    TransferContext::get_instance().read_args(env, args);
-
-    Variant result {from_uint_to_ptr<Callable>(p_raw_ptr)->bindv(args[0])};
-    TransferContext::get_instance().write_return_value(env, result);
-}
-
-void CallableBridge::engine_call_call(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr) {
+void CallableBridge::engine_call_call(JNIEnv* p_raw_env, jobject _, jlong p_raw_ptr) {
     jni::Env env {p_raw_env};
 
     Variant args[MAX_FUNCTION_ARG_COUNT];
@@ -91,15 +98,6 @@ void CallableBridge::engine_call_call_deferred(JNIEnv* p_raw_env, jobject p_inst
     from_uint_to_ptr<Callable>(p_raw_ptr)->call_deferredp(args_ptr, args_size);
 }
 
-void CallableBridge::engine_call_callv(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr) {
-    jni::Env env {p_raw_env};
-    Variant args[1] = {};
-    TransferContext::get_instance().read_args(env, args);
-
-    Variant result {from_uint_to_ptr<Callable>(p_raw_ptr)->callv(args[0])};
-    TransferContext::get_instance().write_return_value(env, result);
-}
-
 void CallableBridge::engine_call_get_bound_arguments(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr) {
     jni::Env env {p_raw_env};
 
@@ -208,4 +206,4 @@ void CallableBridge::engine_call_unbind(JNIEnv* p_raw_env, jobject p_instance, j
     TransferContext::get_instance().write_return_value(env, result);
 }
 
-CallableBridge::~CallableBridge() = default;
\ No newline at end of file
+CallableBridge::~CallableBridge() = default;
diff --git a/src/jvm_wrapper/bridge/callable_bridge.h b/src/jvm_wrapper/bridge/callable_bridge.h
index 5c38885fb..e1648f3e2 100644
--- a/src/jvm_wrapper/bridge/callable_bridge.h
+++ b/src/jvm_wrapper/bridge/callable_bridge.h
@@ -4,20 +4,19 @@
 #include "jvm_wrapper/jvm_singleton_wrapper.h"
 
 namespace bridges {
-    JVM_SINGLETON_WRAPPER(CallableBridge, "godot.core.NativeCallable$Bridge") {
+    JVM_SINGLETON_WRAPPER(CallableBridge, "godot.core.Callable$Bridge") {
         SINGLETON_CLASS(CallableBridge)
 
         // clang-format off
         INIT_JNI_BINDINGS(
             INIT_NATIVE_METHOD("engine_call_constructor", "()J", CallableBridge::engine_call_constructor)
-            INIT_NATIVE_METHOD("engine_call_constructor_object_string_name", "()J", CallableBridge::engine_call_constructor_object_string_name)
-            INIT_NATIVE_METHOD("engine_call_constructor_kt_custom_callable", "(Lgodot/core/LambdaCallable;IIZ)J", CallableBridge::engine_call_constructor_kt_custom_callable)
+            INIT_NATIVE_METHOD("engine_call_constructor_object_string_name", "(JJ)J", CallableBridge::engine_call_constructor_object_string_name)
+            INIT_NATIVE_METHOD("engine_call_constructor_lambda_callable", "(Lgodot/core/LambdaContainer;II)J", CallableBridge::engine_call_constructor_lambda_callable)
+            INIT_NATIVE_METHOD("engine_call_constructor_cancellable", "(Lgodot/core/LambdaContainer;II)V", CallableBridge::engine_call_constructor_cancellable)
             INIT_NATIVE_METHOD("engine_call_copy_constructor", "()J", CallableBridge::engine_call_copy_constructor)
             INIT_NATIVE_METHOD("engine_call_bind", "(J)V", CallableBridge::engine_call_bind)
-            INIT_NATIVE_METHOD("engine_call_bindv", "(J)V", CallableBridge::engine_call_bindv)
             INIT_NATIVE_METHOD("engine_call_call", "(J)V", CallableBridge::engine_call_call)
             INIT_NATIVE_METHOD("engine_call_call_deferred", "(J)V", CallableBridge::engine_call_call_deferred)
-            INIT_NATIVE_METHOD("engine_call_callv", "(J)V", CallableBridge::engine_call_callv)
             INIT_NATIVE_METHOD("engine_call_get_bound_arguments", "(J)V", CallableBridge::engine_call_get_bound_arguments)
             INIT_NATIVE_METHOD("engine_call_get_bound_arguments_count", "(J)V", CallableBridge::engine_call_get_bound_arguments_count)
             INIT_NATIVE_METHOD("engine_call_get_method", "(J)V", CallableBridge::engine_call_get_method)
@@ -35,36 +34,41 @@ namespace bridges {
         // clang-format on
 
     public:
-        static uintptr_t engine_call_constructor(JNIEnv* p_raw_env, jobject p_instance);
+        static uintptr_t engine_call_constructor(JNIEnv * p_raw_env, jobject p_instance);
+        static uintptr_t engine_call_constructor_object_string_name(JNIEnv * p_raw_env, jobject p_instance, jlong object_ptr, jlong method_name_ptr);
+        static uintptr_t engine_call_constructor_lambda_callable(
+          JNIEnv * p_raw_env,
+          jobject p_instance,
+          jobject p_lambda_container,
+          jint p_variant_type_ordinal,
+          jint p_hash_code
+        );
+        static void engine_call_constructor_cancellable(
+          JNIEnv * p_raw_env,
+          jobject p_instance,
+          jobject p_kt_custom_callable_instance,
+          jint p_variant_type_ordinal,
+          jint p_hash_code
+        );
+        static uintptr_t engine_call_copy_constructor(JNIEnv * p_raw_env, jobject p_instance);
 
-        static uintptr_t engine_call_constructor_object_string_name(JNIEnv* p_raw_env, jobject p_instance);
-
-        static uintptr_t engine_call_constructor_kt_custom_callable(JNIEnv* p_raw_env, jobject p_instance,
-                                                                    jobject p_kt_custom_callable_instance,
-                                                                    jint p_variant_type_ordinal, jint p_hash_code,
-                                                                    jboolean p_has_on_destroy);
-
-        static uintptr_t engine_call_copy_constructor(JNIEnv* p_raw_env, jobject p_instance);
-
-        static void engine_call_bind(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_bindv(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_call(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_call_deferred(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_callv(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_get_bound_arguments(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_get_bound_arguments_count(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_get_method(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_get_object(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_get_object_id(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_hash(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_is_custom(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_is_null(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_is_standard(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_is_valid(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_rpc(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_rpc_id(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
-        static void engine_call_unbind(JNIEnv* p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_bind(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_call(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_call_deferred(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_get_bound_arguments(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_get_bound_arguments_count(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_get_method(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_get_object(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_get_object_id(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_hash(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_is_custom(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_is_null(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_is_standard(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_is_valid(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_rpc(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_rpc_id(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
+        static void engine_call_unbind(JNIEnv * p_raw_env, jobject p_instance, jlong p_raw_ptr);
     };
-}// namespace bridge
+} // namespace bridges
 
-#endif// GODOT_JVM_CALLABLE_BRIDGE_H
+#endif // GODOT_JVM_CALLABLE_BRIDGE_H
diff --git a/src/jvm_wrapper/bridge/lambda_callable_bridge.cpp b/src/jvm_wrapper/bridge/lambda_callable_bridge.cpp
deleted file mode 100644
index 4489954d9..000000000
--- a/src/jvm_wrapper/bridge/lambda_callable_bridge.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "lambda_callable_bridge.h"
-
-#include "jvm_wrapper/kotlin_callable_custom.h"
-
-using namespace bridges;
-
-uintptr_t LambdaCallableBridge::wrap_in_custom_callable(JNIEnv* p_raw_env, jobject p_instance,
-                                                    jobject p_kt_custom_callable_instance, jint p_variant_type_ordinal,
-                                                    jint p_hash_code, jboolean p_has_on_destroy) {
-    jni::Env env {p_raw_env};
-    return reinterpret_cast<uintptr_t>(
-        memnew(KotlinCallableCustom(env, p_kt_custom_callable_instance, static_cast<Variant::Type>(p_variant_type_ordinal), p_hash_code, p_has_on_destroy))
-    );
-}
-
-LambdaCallableBridge::~LambdaCallableBridge() = default;
diff --git a/src/jvm_wrapper/bridge/lambda_callable_bridge.h b/src/jvm_wrapper/bridge/lambda_callable_bridge.h
deleted file mode 100644
index fb95805e1..000000000
--- a/src/jvm_wrapper/bridge/lambda_callable_bridge.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef GODOT_JVM_LAMBDA_CALLABLE_BRIDGE_H
-#define GODOT_JVM_LAMBDA_CALLABLE_BRIDGE_H
-
-#include "jvm_wrapper/jvm_singleton_wrapper.h"
-
-namespace bridges {
-    JVM_SINGLETON_WRAPPER(LambdaCallableBridge, "godot.core.LambdaCallable$Bridge") {
-        SINGLETON_CLASS(LambdaCallableBridge)
-
-        // clang-format off
-        INIT_JNI_BINDINGS(
-            INIT_NATIVE_METHOD("wrap_in_custom_callable", "(Lgodot/core/LambdaCallable;IIZ)J", LambdaCallableBridge::wrap_in_custom_callable)
-        )
-        // clang-format on
-
-    public:
-        static uintptr_t wrap_in_custom_callable(JNIEnv* p_raw_env, jobject p_instance, jobject p_kt_custom_callable_instance, jint p_variant_type_ordinal, jint p_hash_code, jboolean p_has_on_destroy);
-    };
-}
-
-
-#endif// GODOT_JVM_LAMBDA_CALLABLE_BRIDGE_H
diff --git a/src/jvm_wrapper/kotlin_callable_custom.cpp b/src/jvm_wrapper/kotlin_callable_custom.cpp
index 7f4b81662..af25552ec 100644
--- a/src/jvm_wrapper/kotlin_callable_custom.cpp
+++ b/src/jvm_wrapper/kotlin_callable_custom.cpp
@@ -1,13 +1,16 @@
 #include "kotlin_callable_custom.h"
-#include "jvm_wrapper/memory/transfer_context.h"
+
 #include "gd_kotlin.h"
+#include "jvm_wrapper/memory/transfer_context.h"
 
-void LambdaCallable::invoke(jni::Env& p_env, const Variant** p_args, int args_count, Variant& r_ret) const {
-    TransferContext& transfer_context{TransferContext::get_instance()};
+void LambdaContainer::invoke(jni::Env& p_env, const Variant** p_args, int args_count, Variant& r_ret) const {
+    TransferContext& transfer_context {TransferContext::get_instance()};
     transfer_context.write_args(p_env, p_args, args_count);
 
+    has_been_called = true;
+
     if (has_return_value) {
-        jni::JObject ret{wrapped.call_object_method<false>(p_env, INVOKE_WITH_RETURN)};
+        jni::JObject ret {wrapped.call_object_method<false>(p_env, INVOKE_WITH_RETURN)};
         transfer_context.read_return_value(p_env, r_ret);
         ret.delete_local_ref(p_env);
 
@@ -15,88 +18,68 @@ void LambdaCallable::invoke(jni::Env& p_env, const Variant** p_args, int args_co
     }
 
     wrapped.call_void_method<false>(p_env, INVOKE_NO_RETURN);
-
-    has_been_called = true;
-}
-
-void LambdaCallable::on_destroy(jni::Env& p_env) const {
-    if (!has_on_cancel || has_been_called) {
-        return;
-    }
-
-    wrapped.call_void_method<false>(p_env, ON_CANCEL);
 }
 
-int LambdaCallable::get_hash_code() const {
+int LambdaContainer::get_hash_code() const {
     return hash_code;
 }
 
-bool LambdaCallable::equals(const LambdaCallable& other) const {
-    jni::Env env{jni::Jvm::current_env()};
+bool LambdaContainer::equals(const LambdaContainer& other) const {
+    jni::Env env {jni::Jvm::current_env()};
     return wrapped.is_same_object(env, other.wrapped);
 }
 
-LambdaCallable::LambdaCallable(jni::Env& p_env, jni::JObject p_wrapped, Variant::Type return_type, int p_hash_code,
-                               bool p_has_on_cancel) : JvmInstanceWrapper(p_env, p_wrapped) {
-    has_return_value = return_type != Variant::NIL;
+LambdaContainer::LambdaContainer(jni::Env& p_env, jni::JObject p_wrapped, Variant::Type return_type, int p_hash_code, bool p_has_on_cancel) :
+  JvmInstanceWrapper(p_env, p_wrapped),
+  hash_code {p_hash_code},
+  has_return_value {return_type != Variant::NIL},
+  has_on_cancel {p_has_on_cancel},
+  has_been_called {false} {}
 
-    hash_code = p_hash_code;
-    has_on_cancel = p_has_on_cancel;
-    has_been_called = false;
-}
+LambdaContainer::~LambdaContainer() {
+    if (!has_on_cancel || has_been_called) { return; }
 
+    jni::Env env {jni::Jvm::current_env()};
+    wrapped.call_void_method<false>(env, CANCEL);
+}
 
-void KotlinCallableCustom::call(const Variant** p_arguments, int p_argcount, Variant& r_return_value,
-                                Callable::CallError& r_call_error) const {
-    jni::Env env{jni::Jvm::current_env()};
-    kt_callable.invoke(env, p_arguments, p_argcount, r_return_value);
+void JvmCallableCustom::call(const Variant** p_arguments, int p_argcount, Variant& r_return_value, Callable::CallError& r_call_error) const {
+    jni::Env env {jni::Jvm::current_env()};
+    lambda.invoke(env, p_arguments, p_argcount, r_return_value);
 }
 
-uint32_t KotlinCallableCustom::hash() const {
-    return kt_callable.get_hash_code();
+uint32_t JvmCallableCustom::hash() const {
+    return lambda.get_hash_code();
 }
 
-String KotlinCallableCustom::get_as_text() const {
-    return "KotlinCallableCustom::invoke";
+String JvmCallableCustom::get_as_text() const {
+    return "JvmCallableCustom::invoke";
 }
 
-ObjectID KotlinCallableCustom::get_object() const {
+ObjectID JvmCallableCustom::get_object() const {
     return GDKotlin::get_instance().get_callable_middleman()->get_instance_id();
 }
 
-CallableCustom::CompareEqualFunc KotlinCallableCustom::get_compare_equal_func() const {
-    return &KotlinCallableCustom::compare_equal;
+CallableCustom::CompareEqualFunc JvmCallableCustom::get_compare_equal_func() const {
+    return &JvmCallableCustom::compare_equal;
 }
 
-CallableCustom::CompareLessFunc KotlinCallableCustom::get_compare_less_func() const {
-    return &KotlinCallableCustom::compare_less;
+CallableCustom::CompareLessFunc JvmCallableCustom::get_compare_less_func() const {
+    return &JvmCallableCustom::compare_less;
 }
 
-bool KotlinCallableCustom::compare_equal(const CallableCustom* p_a, const CallableCustom* p_b) {
-    auto a{dynamic_cast<const KotlinCallableCustom*>(p_a)};
-    auto b{dynamic_cast<const KotlinCallableCustom*>(p_b)};
-
-    if (!a || !b) {
-        return false;
-    }
+bool JvmCallableCustom::compare_equal(const CallableCustom* p_a, const CallableCustom* p_b) {
+    // Function only called by Godot when both callable are confirmed to be the same custom type.
+    // Therefore, those 2 pointers are guaranteed to be instances of this class.
+    auto a {reinterpret_cast<const JvmCallableCustom*>(p_a)};
+    auto b {reinterpret_cast<const JvmCallableCustom*>(p_b)};
 
-    return a->kt_callable.equals(b->kt_callable);
+    return a->lambda.equals(b->lambda);
 }
 
-bool KotlinCallableCustom::compare_less(const CallableCustom* p_a, const CallableCustom* p_b) {
+bool JvmCallableCustom::compare_less(const CallableCustom* p_a, const CallableCustom* p_b) {
     return !compare_equal(p_a, p_b) && p_a < p_b;
 }
 
-KotlinCallableCustom::KotlinCallableCustom(jni::Env& p_env, jni::JObject p_wrapped, Variant::Type return_type,
-                                           int p_hash_code, bool p_has_on_destroy) : CallableCustom(),
-                                                                                     kt_callable(p_env, p_wrapped,
-                                                                                                 return_type,
-                                                                                                 p_hash_code,
-                                                                                                 p_has_on_destroy) {
-
-}
-
-KotlinCallableCustom::~KotlinCallableCustom() {
-    jni::Env env{jni::Jvm::current_env()};
-    kt_callable.on_destroy(env);
-}
+JvmCallableCustom::JvmCallableCustom(jni::Env& p_env, jni::JObject p_wrapped, Variant::Type return_type, int p_hash_code, bool p_has_on_destroy) :
+  lambda(p_env, p_wrapped, return_type, p_hash_code, p_has_on_destroy) {}
\ No newline at end of file
diff --git a/src/jvm_wrapper/kotlin_callable_custom.h b/src/jvm_wrapper/kotlin_callable_custom.h
index e6d32601c..9544ccbe5 100644
--- a/src/jvm_wrapper/kotlin_callable_custom.h
+++ b/src/jvm_wrapper/kotlin_callable_custom.h
@@ -4,33 +4,28 @@
 #include "jvm_wrapper/jvm_instance_wrapper.h"
 #include "core/variant/callable.h"
 
-JVM_INSTANCE_WRAPPER(LambdaCallable, "godot.core.LambdaCallable") {
-    JVM_CLASS(LambdaCallable)
-    // clang-format off
+JVM_INSTANCE_WRAPPER(LambdaContainer, "godot.core.LambdaContainer") {
+    JVM_CLASS(LambdaContainer)
 
+    // clang-format off
     JNI_VOID_METHOD(INVOKE_NO_RETURN)
     JNI_OBJECT_METHOD(INVOKE_WITH_RETURN)
-    JNI_INT_METHOD(GET_RETURN_VARIANT_TYPE)
-    JNI_INT_METHOD(HASH_CODE)
-    JNI_VOID_METHOD(ON_CANCEL)
+    JNI_VOID_METHOD(CANCEL)
 
     INIT_JNI_BINDINGS(
-        INIT_JNI_METHOD(INVOKE_NO_RETURN, "invokeNoReturn", "()V")
+        INIT_JNI_METHOD(INVOKE_NO_RETURN, "invoke", "()V")
         INIT_JNI_METHOD(INVOKE_WITH_RETURN, "invokeWithReturn", "()Ljava/lang/Object;")
-        INIT_JNI_METHOD(GET_RETURN_VARIANT_TYPE, "getReturnVariantType", "()I")
-        INIT_JNI_METHOD(HASH_CODE, "hashCode", "()I")
-        INIT_JNI_METHOD(ON_CANCEL, "onCancel", "()V")
+        INIT_JNI_METHOD(CANCEL, "cancel", "()V")
     )
-
     // clang-format on
 
 public:
     void invoke(jni::Env& p_env, const Variant** p_args, int args_count, Variant& r_ret) const;
-    void on_destroy(jni::Env& p_env) const;
     int get_hash_code() const;
-    bool equals(const LambdaCallable& other) const;
+    bool equals(const LambdaContainer& other) const;
 
-    LambdaCallable(jni::Env& p_env, jni::JObject p_wrapped, Variant::Type return_type, int p_hash_code, bool p_has_on_cancel);
+    LambdaContainer(jni::Env& p_env, jni::JObject p_wrapped, Variant::Type return_type, int p_hash_code, bool p_has_on_cancel);
+    ~LambdaContainer();
 
 private:
     int hash_code;
@@ -39,7 +34,7 @@ JVM_INSTANCE_WRAPPER(LambdaCallable, "godot.core.LambdaCallable") {
     mutable bool has_been_called;
 };
 
-class KotlinCallableCustom : public CallableCustom {
+class JvmCallableCustom : public CallableCustom {
 public:
     void call(const Variant** p_arguments, int p_argcount, Variant& r_return_value, Callable::CallError& r_call_error) const override;
 
@@ -49,11 +44,11 @@ class KotlinCallableCustom : public CallableCustom {
     CompareLessFunc get_compare_less_func() const override;
     ObjectID get_object() const override;
 
-    KotlinCallableCustom(jni::Env& p_env, jni::JObject p_wrapped, Variant::Type return_type, int p_hash_code, bool p_has_on_destroy);
-    ~KotlinCallableCustom();
+    JvmCallableCustom(jni::Env& p_env, jni::JObject p_wrapped, Variant::Type return_type, int p_hash_code, bool p_has_on_destroy);
+    ~JvmCallableCustom() = default;
 
 private:
-    LambdaCallable kt_callable;
+    LambdaContainer lambda;
 
     static bool compare_equal(const CallableCustom* p_a, const CallableCustom* p_b);
     static bool compare_less(const CallableCustom* p_a, const CallableCustom* p_b);
diff --git a/src/jvm_wrapper/memory/transfer_context.cpp b/src/jvm_wrapper/memory/transfer_context.cpp
index 6b3db4dee..81523ce55 100644
--- a/src/jvm_wrapper/memory/transfer_context.cpp
+++ b/src/jvm_wrapper/memory/transfer_context.cpp
@@ -97,8 +97,8 @@ void TransferContext::icall(JNIEnv* rawEnv, jobject instance, jlong j_ptr, jlong
         }
 
         const Variant& ret_value {method_bind->call(ptr, args_ptr, args_size, r_error)};
-
         buffer->rewind();
+
         VariantToBuffer::write_variant(ret_value, buffer);
     } else {
         Variant* args {variant_args + stack_offset};
diff --git a/src/kt_variant.h b/src/kt_variant.h
index ca4ead8fc..1fb491499 100644
--- a/src/kt_variant.h
+++ b/src/kt_variant.h
@@ -237,14 +237,6 @@ class BufferToVariant {
         return Variant(Signal(object, name));
     }
 
-    static Variant read_callable(SharedBuffer* byte_buffer) {
-        bool is_custom {static_cast<bool>(decode_uint32(byte_buffer->get_cursor()))};
-        byte_buffer->increment_position(BOOL_SIZE);
-
-        if (is_custom) { return Callable(read_pointer<CallableCustom>(byte_buffer)); }
-
-        return *read_pointer<Callable>(byte_buffer);
-    }
 
 public:
 
@@ -281,7 +273,7 @@ class BufferToVariant {
           &BufferToVariant::read_native_core_type<NodePath>,
           &BufferToVariant::read_core_type<RID>,
           &BufferToVariant::read_object,
-          &BufferToVariant::read_callable,
+          &BufferToVariant::read_native_core_type<Callable>,
           &BufferToVariant::read_signal,
           &BufferToVariant::read_native_core_type<Dictionary>,
           &BufferToVariant::read_native_core_type<Array>,
diff --git a/src/lifecycle/jvm_manager.cpp b/src/lifecycle/jvm_manager.cpp
index dea3def6e..d3b6e547a 100644
--- a/src/lifecycle/jvm_manager.cpp
+++ b/src/lifecycle/jvm_manager.cpp
@@ -4,7 +4,6 @@
 #include "jvm_wrapper/bridge/callable_bridge.h"
 #include "jvm_wrapper/bridge/dictionary_bridge.h"
 #include "jvm_wrapper/bridge/godot_print_bridge.h"
-#include "jvm_wrapper/bridge/lambda_callable_bridge.h"
 #include "jvm_wrapper/bridge/node_path_bridge.h"
 #include "jvm_wrapper/bridge/packed_array_bridge.h"
 #include "jvm_wrapper/bridge/packed_byte_array_bridge.h"
@@ -44,6 +43,7 @@ CreateJavaVM get_create_jvm_function(void* lib_handle) {
 #else
     // Sanity check in case we mess up preprocessors
     JVM_DEV_ASSERT(false, "Current configuration doesn't provide a way to create a JVM!");
+    return nullptr;
 #endif
 }
 
@@ -105,14 +105,13 @@ bool JvmManager::initialize_jvm_wrappers(jni::Env& p_env, ClassLoader* class_loa
             && KtFunctionInfo::initialize(p_env, class_loader)
             && KtFunction::initialize(p_env, class_loader)
             && KtClass::initialize(p_env, class_loader)
-            && LambdaCallable::initialize(p_env, class_loader)
+            && LambdaContainer::initialize(p_env, class_loader)
             && TransferContext::initialize(p_env, class_loader)
             && TypeManager::initialize(p_env, class_loader)
             && LongStringQueue::initialize(p_env, class_loader)
             && MemoryManager::initialize(p_env, class_loader)
             && bridges::GodotPrintBridge::initialize(p_env, class_loader)
             && bridges::CallableBridge::initialize(p_env, class_loader)
-            && bridges::LambdaCallableBridge::initialize(p_env, class_loader)
             && bridges::DictionaryBridge::initialize(p_env, class_loader)
             && bridges::StringNameBridge::initialize(p_env, class_loader)
             && bridges::NodePathBridge::initialize(p_env, class_loader)
@@ -142,7 +141,6 @@ void JvmManager::finalize_jvm_wrappers(jni::Env& p_env, ClassLoader* class_loade
     MemoryManager::finalize(p_env, class_loader);
     bridges::GodotPrintBridge::finalize(p_env, class_loader);
     bridges::CallableBridge::finalize(p_env, class_loader);
-    bridges::LambdaCallableBridge::finalize(p_env, class_loader);
     bridges::DictionaryBridge::finalize(p_env, class_loader);
     bridges::StringNameBridge::finalize(p_env, class_loader);
     bridges::NodePathBridge::finalize(p_env, class_loader);
@@ -157,6 +155,7 @@ void JvmManager::finalize_jvm_wrappers(jni::Env& p_env, ClassLoader* class_loade
     bridges::PackedVector2ArrayBridge::finalize(p_env, class_loader);
     bridges::PackedVector3ArrayBridge::finalize(p_env, class_loader);
     bridges::PackedVector4ArrayBridge::finalize(p_env, class_loader);
+    LambdaContainer::finalize(p_env, class_loader);
     KtObject::finalize(p_env, class_loader);
     KtPropertyInfo::finalize(p_env, class_loader);
     KtProperty::finalize(p_env, class_loader);
@@ -170,8 +169,6 @@ void JvmManager::finalize_jvm_wrappers(jni::Env& p_env, ClassLoader* class_loade
 
 void JvmManager::close_jvm() {
 #if defined DYNAMIC_JVM || defined STATIC_JVM
-    //TODO: Remove the return jvm when https://github.com/godotengine/godot/issues/95809 is resolved
-    return;
     JVM_LOG_VERBOSE("Shutting down JVM ...");
     jni::Jvm::destroy();
 #endif
diff --git a/src/lifecycle/jvm_user_configuration.cpp b/src/lifecycle/jvm_user_configuration.cpp
index ed8244df9..03edf7f02 100644
--- a/src/lifecycle/jvm_user_configuration.cpp
+++ b/src/lifecycle/jvm_user_configuration.cpp
@@ -278,9 +278,11 @@ void JvmUserConfiguration::parse_command_line(const List<String>& args, HashMap<
             configuration_map[JVM_ARGUMENTS_CMD_IDENTIFIER] = arr;
         }
 
+#ifdef DEV_ENABLED
         for (const auto& map_element : configuration_map) {
             JVM_DEV_VERBOSE("Value for commandline argument: %s -> %s", map_element.key, map_element.value);
         }
+#endif
     }
 }