@fressh/react-native-terminal 0.1.0

package/cpp/generated/shim_uniffi.cpp

@@ -0,0 +1,4246 @@
+// This file was autogenerated by some hot garbage in the
+// `uniffi-bindgen-react-native` crate. Trust me, you don't want to mess with
+// it!
+#include "shim_uniffi.hpp"
+
+#include "UniffiJsiTypes.h"
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <thread>
+#include <utility>
+
+namespace react = facebook::react;
+namespace jsi = facebook::jsi;
+
+// Calling into Rust.
+extern "C" {
+typedef void (*UniffiRustFutureContinuationCallback)(uint64_t data,
+                                                     int8_t poll_result);
+typedef void (*UniffiForeignFutureDroppedCallback)(uint64_t handle);
+typedef void (*UniffiCallbackInterfaceFree)(uint64_t handle);
+typedef uint64_t (*UniffiCallbackInterfaceClone)(uint64_t handle);
+typedef struct UniffiForeignFutureDroppedCallbackStruct {
+  uint64_t handle;
+  UniffiForeignFutureDroppedCallback free;
+} UniffiForeignFutureDroppedCallbackStruct;
+typedef struct UniffiForeignFutureResultU8 {
+  uint8_t return_value;
+  RustCallStatus call_status;
+} UniffiForeignFutureResultU8;
+typedef void (*UniffiForeignFutureCompleteU8)(
+    uint64_t callback_data, UniffiForeignFutureResultU8 result);
+typedef struct UniffiForeignFutureResultI8 {
+  int8_t return_value;
+  RustCallStatus call_status;
+} UniffiForeignFutureResultI8;
+typedef void (*UniffiForeignFutureCompleteI8)(
+    uint64_t callback_data, UniffiForeignFutureResultI8 result);
+typedef struct UniffiForeignFutureResultU16 {
+  uint16_t return_value;
+  RustCallStatus call_status;
+} UniffiForeignFutureResultU16;
+typedef void (*UniffiForeignFutureCompleteU16)(
+    uint64_t callback_data, UniffiForeignFutureResultU16 result);
+typedef struct UniffiForeignFutureResultI16 {
+  int16_t return_value;
+  RustCallStatus call_status;
+} UniffiForeignFutureResultI16;
+typedef void (*UniffiForeignFutureCompleteI16)(
+    uint64_t callback_data, UniffiForeignFutureResultI16 result);
+typedef struct UniffiForeignFutureResultU32 {
+  uint32_t return_value;
+  RustCallStatus call_status;
+} UniffiForeignFutureResultU32;
+typedef void (*UniffiForeignFutureCompleteU32)(
+    uint64_t callback_data, UniffiForeignFutureResultU32 result);
+typedef struct UniffiForeignFutureResultI32 {
+  int32_t return_value;
+  RustCallStatus call_status;
+} UniffiForeignFutureResultI32;
+typedef void (*UniffiForeignFutureCompleteI32)(
+    uint64_t callback_data, UniffiForeignFutureResultI32 result);
+typedef struct UniffiForeignFutureResultU64 {
+  uint64_t return_value;
+  RustCallStatus call_status;
+} UniffiForeignFutureResultU64;
+typedef void (*UniffiForeignFutureCompleteU64)(
+    uint64_t callback_data, UniffiForeignFutureResultU64 result);
+typedef struct UniffiForeignFutureResultI64 {
+  int64_t return_value;
+  RustCallStatus call_status;
+} UniffiForeignFutureResultI64;
+typedef void (*UniffiForeignFutureCompleteI64)(
+    uint64_t callback_data, UniffiForeignFutureResultI64 result);
+typedef struct UniffiForeignFutureResultF32 {
+  float return_value;
+  RustCallStatus call_status;
+} UniffiForeignFutureResultF32;
+typedef void (*UniffiForeignFutureCompleteF32)(
+    uint64_t callback_data, UniffiForeignFutureResultF32 result);
+typedef struct UniffiForeignFutureResultF64 {
+  double return_value;
+  RustCallStatus call_status;
+} UniffiForeignFutureResultF64;
+typedef void (*UniffiForeignFutureCompleteF64)(
+    uint64_t callback_data, UniffiForeignFutureResultF64 result);
+typedef struct UniffiForeignFutureResultRustBuffer {
+  RustBuffer return_value;
+  RustCallStatus call_status;
+} UniffiForeignFutureResultRustBuffer;
+typedef void (*UniffiForeignFutureCompleteRustBuffer)(
+    uint64_t callback_data, UniffiForeignFutureResultRustBuffer result);
+typedef struct UniffiForeignFutureResultVoid {
+  RustCallStatus call_status;
+} UniffiForeignFutureResultVoid;
+typedef void (*UniffiForeignFutureCompleteVoid)(
+    uint64_t callback_data, UniffiForeignFutureResultVoid result);
+typedef void (*UniffiCallbackInterfaceFresshEventListenerMethod0)(
+    uint64_t uniffi_handle, RustBuffer event, void *uniffi_out_return,
+    RustCallStatus *rust_call_status);
+typedef struct UniffiVTableCallbackInterfaceFresshEventListener {
+  UniffiCallbackInterfaceFree uniffi_free;
+  UniffiCallbackInterfaceClone uniffi_clone;
+  UniffiCallbackInterfaceFresshEventListenerMethod0 on_event;
+} UniffiVTableCallbackInterfaceFresshEventListener;
+/*handle*/ uint64_t uniffi_shim_uniffi_fn_clone_fressheventlistener(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void uniffi_shim_uniffi_fn_free_fressheventlistener(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void uniffi_shim_uniffi_fn_init_callback_vtable_fressheventlistener(
+    UniffiVTableCallbackInterfaceFresshEventListener *vtable);
+void uniffi_shim_uniffi_fn_method_fressheventlistener_on_event(
+    /*handle*/ uint64_t ptr, RustBuffer event, RustCallStatus *uniffi_out_err);
+/*handle*/ uint64_t
+uniffi_shim_uniffi_fn_func_close_preview(RustBuffer preview_id);
+/*handle*/ uint64_t uniffi_shim_uniffi_fn_func_close_shell(RustBuffer shell_id);
+/*handle*/ uint64_t uniffi_shim_uniffi_fn_func_connect(RustBuffer details);
+void uniffi_shim_uniffi_fn_func_create_preview(RustBuffer preview_id,
+                                               RustBuffer demo,
+                                               RustCallStatus *uniffi_out_err);
+/*handle*/ uint64_t
+uniffi_shim_uniffi_fn_func_disconnect(RustBuffer connection_id);
+RustBuffer
+uniffi_shim_uniffi_fn_func_generate_key_pair(RustBuffer key_type,
+                                             RustCallStatus *uniffi_out_err);
+/*handle*/ uint64_t uniffi_shim_uniffi_fn_func_resize(RustBuffer shell_id,
+                                                      uint32_t cols,
+                                                      uint32_t rows);
+void uniffi_shim_uniffi_fn_func_respond_to_host_key(
+    RustBuffer connection_id, int8_t accept, RustCallStatus *uniffi_out_err);
+/*handle*/ uint64_t
+uniffi_shim_uniffi_fn_func_run_command(RustBuffer connection_id,
+                                       RustBuffer command);
+/*handle*/ uint64_t uniffi_shim_uniffi_fn_func_scroll(RustBuffer shell_id,
+                                                      float delta_px);
+void uniffi_shim_uniffi_fn_func_selection_clear(RustBuffer shell_id,
+                                                RustCallStatus *uniffi_out_err);
+void uniffi_shim_uniffi_fn_func_selection_start(RustBuffer shell_id, float x,
+                                                float y, RustBuffer kind,
+                                                RustCallStatus *uniffi_out_err);
+RustBuffer
+uniffi_shim_uniffi_fn_func_selection_text(RustBuffer shell_id,
+                                          RustCallStatus *uniffi_out_err);
+void uniffi_shim_uniffi_fn_func_selection_update(
+    RustBuffer shell_id, float x, float y, RustCallStatus *uniffi_out_err);
+/*handle*/ uint64_t uniffi_shim_uniffi_fn_func_send_data(RustBuffer shell_id,
+                                                         RustBuffer data);
+void uniffi_shim_uniffi_fn_func_set_event_listener(
+    /*handle*/ uint64_t listener, RustCallStatus *uniffi_out_err);
+/*handle*/ uint64_t
+uniffi_shim_uniffi_fn_func_start_shell(RustBuffer connection_id,
+                                       RustBuffer options);
+RustBuffer
+uniffi_shim_uniffi_fn_func_validate_private_key(RustBuffer pem,
+                                                RustCallStatus *uniffi_out_err);
+RustBuffer ffi_shim_uniffi_rustbuffer_alloc(uint64_t size,
+                                            RustCallStatus *uniffi_out_err);
+RustBuffer
+ffi_shim_uniffi_rustbuffer_from_bytes(ForeignBytes bytes,
+                                      RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rustbuffer_free(RustBuffer buf,
+                                     RustCallStatus *uniffi_out_err);
+RustBuffer ffi_shim_uniffi_rustbuffer_reserve(RustBuffer buf,
+                                              uint64_t additional,
+                                              RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rust_future_poll_u8(
+    /*handle*/ uint64_t handle, UniffiRustFutureContinuationCallback callback,
+    /*handle*/ uint64_t callback_data);
+void ffi_shim_uniffi_rust_future_cancel_u8(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_free_u8(
+    /*handle*/ uint64_t handle);
+uint8_t ffi_shim_uniffi_rust_future_complete_u8(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rust_future_poll_i8(
+    /*handle*/ uint64_t handle, UniffiRustFutureContinuationCallback callback,
+    /*handle*/ uint64_t callback_data);
+void ffi_shim_uniffi_rust_future_cancel_i8(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_free_i8(
+    /*handle*/ uint64_t handle);
+int8_t ffi_shim_uniffi_rust_future_complete_i8(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rust_future_poll_u16(
+    /*handle*/ uint64_t handle, UniffiRustFutureContinuationCallback callback,
+    /*handle*/ uint64_t callback_data);
+void ffi_shim_uniffi_rust_future_cancel_u16(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_free_u16(
+    /*handle*/ uint64_t handle);
+uint16_t ffi_shim_uniffi_rust_future_complete_u16(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rust_future_poll_i16(
+    /*handle*/ uint64_t handle, UniffiRustFutureContinuationCallback callback,
+    /*handle*/ uint64_t callback_data);
+void ffi_shim_uniffi_rust_future_cancel_i16(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_free_i16(
+    /*handle*/ uint64_t handle);
+int16_t ffi_shim_uniffi_rust_future_complete_i16(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rust_future_poll_u32(
+    /*handle*/ uint64_t handle, UniffiRustFutureContinuationCallback callback,
+    /*handle*/ uint64_t callback_data);
+void ffi_shim_uniffi_rust_future_cancel_u32(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_free_u32(
+    /*handle*/ uint64_t handle);
+uint32_t ffi_shim_uniffi_rust_future_complete_u32(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rust_future_poll_i32(
+    /*handle*/ uint64_t handle, UniffiRustFutureContinuationCallback callback,
+    /*handle*/ uint64_t callback_data);
+void ffi_shim_uniffi_rust_future_cancel_i32(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_free_i32(
+    /*handle*/ uint64_t handle);
+int32_t ffi_shim_uniffi_rust_future_complete_i32(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rust_future_poll_u64(
+    /*handle*/ uint64_t handle, UniffiRustFutureContinuationCallback callback,
+    /*handle*/ uint64_t callback_data);
+void ffi_shim_uniffi_rust_future_cancel_u64(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_free_u64(
+    /*handle*/ uint64_t handle);
+uint64_t ffi_shim_uniffi_rust_future_complete_u64(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rust_future_poll_i64(
+    /*handle*/ uint64_t handle, UniffiRustFutureContinuationCallback callback,
+    /*handle*/ uint64_t callback_data);
+void ffi_shim_uniffi_rust_future_cancel_i64(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_free_i64(
+    /*handle*/ uint64_t handle);
+int64_t ffi_shim_uniffi_rust_future_complete_i64(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rust_future_poll_f32(
+    /*handle*/ uint64_t handle, UniffiRustFutureContinuationCallback callback,
+    /*handle*/ uint64_t callback_data);
+void ffi_shim_uniffi_rust_future_cancel_f32(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_free_f32(
+    /*handle*/ uint64_t handle);
+float ffi_shim_uniffi_rust_future_complete_f32(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rust_future_poll_f64(
+    /*handle*/ uint64_t handle, UniffiRustFutureContinuationCallback callback,
+    /*handle*/ uint64_t callback_data);
+void ffi_shim_uniffi_rust_future_cancel_f64(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_free_f64(
+    /*handle*/ uint64_t handle);
+double ffi_shim_uniffi_rust_future_complete_f64(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rust_future_poll_rust_buffer(
+    /*handle*/ uint64_t handle, UniffiRustFutureContinuationCallback callback,
+    /*handle*/ uint64_t callback_data);
+void ffi_shim_uniffi_rust_future_cancel_rust_buffer(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_free_rust_buffer(
+    /*handle*/ uint64_t handle);
+RustBuffer ffi_shim_uniffi_rust_future_complete_rust_buffer(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+void ffi_shim_uniffi_rust_future_poll_void(
+    /*handle*/ uint64_t handle, UniffiRustFutureContinuationCallback callback,
+    /*handle*/ uint64_t callback_data);
+void ffi_shim_uniffi_rust_future_cancel_void(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_free_void(
+    /*handle*/ uint64_t handle);
+void ffi_shim_uniffi_rust_future_complete_void(
+    /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
+uint16_t uniffi_shim_uniffi_checksum_func_close_preview();
+uint16_t uniffi_shim_uniffi_checksum_func_close_shell();
+uint16_t uniffi_shim_uniffi_checksum_func_connect();
+uint16_t uniffi_shim_uniffi_checksum_func_create_preview();
+uint16_t uniffi_shim_uniffi_checksum_func_disconnect();
+uint16_t uniffi_shim_uniffi_checksum_func_generate_key_pair();
+uint16_t uniffi_shim_uniffi_checksum_func_resize();
+uint16_t uniffi_shim_uniffi_checksum_func_respond_to_host_key();
+uint16_t uniffi_shim_uniffi_checksum_func_run_command();
+uint16_t uniffi_shim_uniffi_checksum_func_scroll();
+uint16_t uniffi_shim_uniffi_checksum_func_selection_clear();
+uint16_t uniffi_shim_uniffi_checksum_func_selection_start();
+uint16_t uniffi_shim_uniffi_checksum_func_selection_text();
+uint16_t uniffi_shim_uniffi_checksum_func_selection_update();
+uint16_t uniffi_shim_uniffi_checksum_func_send_data();
+uint16_t uniffi_shim_uniffi_checksum_func_set_event_listener();
+uint16_t uniffi_shim_uniffi_checksum_func_start_shell();
+uint16_t uniffi_shim_uniffi_checksum_func_validate_private_key();
+uint16_t uniffi_shim_uniffi_checksum_method_fressheventlistener_on_event();
+uint32_t ffi_shim_uniffi_uniffi_contract_version();
+}
+
+namespace uniffi::shim_uniffi {
+template <typename T> struct Bridging;
+
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <typename T> struct Bridging<ReferenceHolder<T>> {
+  static jsi::Value jsNew(jsi::Runtime &rt) {
+    auto holder = jsi::Object(rt);
+    return holder;
+  }
+  static T fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+                  const jsi::Value &value) {
+    auto obj = value.asObject(rt);
+    if (obj.hasProperty(rt, "pointee")) {
+      auto pointee = obj.getProperty(rt, "pointee");
+      return uniffi::shim_uniffi::Bridging<T>::fromJs(rt, callInvoker, pointee);
+    }
+    throw jsi::JSError(rt,
+                       "Expected ReferenceHolder to have a pointee property. "
+                       "This is likely a bug in uniffi-bindgen-react-native");
+  }
+};
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<RustBuffer> {
+  static RustBuffer rustbuffer_alloc(int32_t size) {
+    RustCallStatus status = {UNIFFI_CALL_STATUS_OK};
+    return ffi_shim_uniffi_rustbuffer_alloc(size, &status);
+  }
+
+  static void rustbuffer_free(RustBuffer buf) {
+    RustCallStatus status = {UNIFFI_CALL_STATUS_OK};
+    ffi_shim_uniffi_rustbuffer_free(buf, &status);
+  }
+
+  static RustBuffer rustbuffer_from_bytes(ForeignBytes bytes) {
+    RustCallStatus status = {UNIFFI_CALL_STATUS_OK};
+    return ffi_shim_uniffi_rustbuffer_from_bytes(bytes, &status);
+  }
+
+  static RustBuffer fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker>,
+                           const jsi::Value &value) {
+    try {
+      auto buffer =
+          uniffi_jsi::Bridging<jsi::ArrayBuffer>::value_to_arraybuffer(rt,
+                                                                       value);
+      auto bytes = ForeignBytes{
+          .len = static_cast<int32_t>(buffer.length(rt)),
+          .data = buffer.data(rt),
+      };
+
+      // This buffer is constructed from foreign bytes. Rust scaffolding copies
+      // the bytes, to make the RustBuffer.
+      auto buf = rustbuffer_from_bytes(bytes);
+      // Once it leaves this function, the buffer is immediately passed back
+      // into Rust, where it's used to deserialize into the Rust versions of the
+      // arguments. At that point, the copy is destroyed.
+      return buf;
+    } catch (const std::logic_error &e) {
+      throw jsi::JSError(rt, e.what());
+    }
+  }
+
+  static jsi::Value toJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker>,
+                         RustBuffer buf) {
+    // View-handoff: hand JS a `Uint8Array` view aliasing the Rust-owned bytes
+    // (no boundary copy). The single mandatory copy now happens inside
+    // `converter.lift(view)` (string decode, byte-array `set`, field-by-field
+    // record reads). The codegen-emitted try/finally calls `rustbuffer_free`
+    // on the view after `lift` returns, releasing the Rust allocation.
+    //
+    // Capacity hint: Rust may return a buffer where `capacity > len`. The
+    // view's `byteLength` is `len` (so converters that decode the whole view
+    // see only the message bytes), but `rustbuffer_free` needs `capacity` to
+    // free correctly. We stash `capacity` on the view via a string-keyed
+    // property when it differs from `len`; the JSI `rustbufferFree` host
+    // function reads it back and falls back to `byteLength` for views from
+    // `rustbufferAlloc(n)` where `byteLength == capacity` already.
+    //
+    // CMutableBuffer is non-owning here: its destructor leaves `buf.data`
+    // alone. Only the codegen-emitted `rustbuffer_free` path frees it.
+    auto payload = std::make_shared<uniffi_jsi::CMutableBuffer>(
+        buf.data, static_cast<size_t>(buf.len));
+    auto view =
+        uniffi_jsi::arraybufferToUint8Array(rt, jsi::ArrayBuffer(rt, payload));
+    if (buf.capacity != static_cast<uint64_t>(buf.len)) {
+      view.setProperty(rt, uniffi_jsi::kUbrnRustCapacity,
+                       jsi::Value(static_cast<double>(buf.capacity)));
+    }
+    return jsi::Value(rt, view);
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<RustCallStatus> {
+  static jsi::Value jsSuccess(jsi::Runtime &rt) {
+    auto statusObject = jsi::Object(rt);
+    statusObject.setProperty(rt, "code", jsi::Value(rt, UNIFFI_CALL_STATUS_OK));
+    return statusObject;
+  }
+  static RustCallStatus rustSuccess(jsi::Runtime &rt) {
+    return {UNIFFI_CALL_STATUS_OK};
+  }
+  static void copyIntoJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         const RustCallStatus status,
+                         const jsi::Value &jsStatus) {
+    auto statusObject = jsStatus.asObject(rt);
+    if (status.error_buf.data != nullptr) {
+      // The error path is NOT wrapped in the codegen-emitted try/finally that
+      // covers normal returns: `errorBuf` is read by the runtime's call-status
+      // dispatcher (rust-call.ts) which throws straight to the user without
+      // ever calling `rustbuffer_free`. Switching this site to view-handoff
+      // would leak the Rust allocation, so we keep the copy semantics here:
+      // copy the bytes into a JS-owned ArrayBuffer and free the Rust buffer
+      // immediately. The errorBuf is small (a serialized error variant) and
+      // only allocated on the cold error path, so the boundary copy is cheap.
+      auto len = static_cast<size_t>(status.error_buf.len);
+      uint8_t *bytes = new uint8_t[len];
+      std::memcpy(bytes, status.error_buf.data, len);
+      auto payload = std::make_shared<uniffi_jsi::CMutableBuffer>(bytes, len);
+      auto view = uniffi_jsi::arraybufferToUint8Array(
+          rt, jsi::ArrayBuffer(rt, payload));
+      statusObject.setProperty(rt, "errorBuf", view);
+      Bridging<RustBuffer>::rustbuffer_free(status.error_buf);
+    }
+    if (status.code != UNIFFI_CALL_STATUS_OK) {
+      auto code =
+          uniffi_jsi::Bridging<uint8_t>::toJs(rt, callInvoker, status.code);
+      statusObject.setProperty(rt, "code", code);
+    }
+  }
+
+  static RustCallStatus fromJs(jsi::Runtime &rt,
+                               std::shared_ptr<CallInvoker> invoker,
+                               const jsi::Value &jsStatus) {
+    RustCallStatus status;
+    auto statusObject = jsStatus.asObject(rt);
+    if (statusObject.hasProperty(rt, "errorBuf")) {
+      auto rbuf = statusObject.getProperty(rt, "errorBuf");
+      status.error_buf = Bridging<RustBuffer>::fromJs(rt, invoker, rbuf);
+    }
+    if (statusObject.hasProperty(rt, "code")) {
+      auto code = statusObject.getProperty(rt, "code");
+      status.code = uniffi_jsi::Bridging<uint8_t>::fromJs(rt, invoker, code);
+    }
+    return status;
+  }
+
+  static void copyFromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> invoker,
+                         const jsi::Value &jsStatus, RustCallStatus *status) {
+    auto statusObject = jsStatus.asObject(rt);
+    if (statusObject.hasProperty(rt, "errorBuf")) {
+      auto rbuf = statusObject.getProperty(rt, "errorBuf");
+      status->error_buf = Bridging<RustBuffer>::fromJs(rt, invoker, rbuf);
+    }
+    if (statusObject.hasProperty(rt, "code")) {
+      auto code = statusObject.getProperty(rt, "code");
+      status->code = uniffi_jsi::Bridging<uint8_t>::fromJs(rt, invoker, code);
+    }
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+// In other uniffi bindings, it is assumed that the foreign language holds on
+// to the vtable, which the Rust just gets a pointer to.
+// Here, we need to hold on to them, but also be able to clear them at just the
+// right time so we can support hot-reloading.
+namespace uniffi::shim_uniffi::registry {
+template <typename T> class VTableHolder {
+public:
+  T vtable;
+  VTableHolder(T v) : vtable(v) {}
+};
+
+// Mutex to bind the storage and setting of vtable together.
+// We declare it here, but the lock is taken by callers of the putTable
+// method who are also sending a pointer to Rust.
+static std::mutex vtableMutex;
+
+// Registry to hold all vtables so they persist even when JS objects are GC'd.
+// The only reason this exists is to prevent a dangling pointer in the
+// Rust machinery: i.e. we don't need to access or write to this registry
+// after startup.
+// Registry to hold all vtables so they persist even when JS objects are GC'd.
+// Maps string identifiers to vtable holders using type erasure
+static std::unordered_map<std::string, std::shared_ptr<void>> vtableRegistry;
+
+// Add a vtable to the registry with an identifier
+template <typename T>
+static T *putTable(std::string_view identifier, T vtable) {
+  auto holder = std::make_shared<VTableHolder<T>>(vtable);
+  // Store the raw pointer to the vtable before type erasure
+  T *rawPtr = &(holder->vtable);
+  // Store the holder using type erasure with the string identifier
+  vtableRegistry[std::string(identifier)] = std::shared_ptr<void>(holder);
+  return rawPtr;
+}
+
+// Clear the registry.
+//
+// Conceptually, this is called after teardown of the module (i.e. after
+// teardown of the jsi::Runtime). However, because Rust is dropping callbacks
+// because the Runtime is being torn down, we must keep the registry intact
+// until after the runtime goes away.
+//
+// Therefore, in practice we should call this when the next runtime is
+// being stood up.
+static void clearRegistry() {
+  std::lock_guard<std::mutex> lock(vtableMutex);
+  vtableRegistry.clear();
+}
+} // namespace uniffi::shim_uniffi::registry
+
+// This calls into Rust.
+// Implementation of callback function calling from Rust to JS
+// RustFutureContinuationCallback
+
+// Callback function:
+// uniffi::shim_uniffi::cb::rustfuturecontinuationcallback::UniffiRustFutureContinuationCallback
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::shim_uniffi::cb::rustfuturecontinuationcallback {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t, int8_t)> rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue, uint64_t rs_data,
+                 int8_t rs_pollResult) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_data = uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_data);
+  auto js_pollResult =
+      uniffi_jsi::Bridging<int8_t>::toJs(rt, callInvoker, rs_pollResult);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_data, js_pollResult);
+
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback UniffiRustFutureContinuationCallback: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static void callback(uint64_t rs_data, int8_t rs_pollResult) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return;
+  }
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_data, rs_pollResult);
+}
+
+[[maybe_unused]] static UniffiRustFutureContinuationCallback
+makeCallbackFunction( // uniffi::shim_uniffi::cb::rustfuturecontinuationcallback
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker, callbackValue](uint64_t rs_data,
+                                               int8_t rs_pollResult) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_data,
+         rs_pollResult](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_data, rs_pollResult);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+
+    callInvoker->invokeNonBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeShimUniffi, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace uniffi::shim_uniffi::cb::rustfuturecontinuationcallback
+  // Implementation of callback function calling from Rust to JS
+  // ForeignFutureDroppedCallback
+
+// Callback function:
+// uniffi::shim_uniffi::cb::foreignfuturedroppedcallback::UniffiForeignFutureDroppedCallback
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::shim_uniffi::cb::foreignfuturedroppedcallback {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t)> rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue,
+                 uint64_t rs_handle) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_handle =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_handle);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_handle);
+
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback UniffiForeignFutureDroppedCallback: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static void callback(uint64_t rs_handle) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return;
+  }
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_handle);
+}
+
+[[maybe_unused]] static UniffiForeignFutureDroppedCallback
+makeCallbackFunction( // uniffi::shim_uniffi::cb::foreignfuturedroppedcallback
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker, callbackValue](uint64_t rs_handle) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_handle](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_handle);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+
+    callInvoker->invokeNonBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeShimUniffi, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace uniffi::shim_uniffi::cb::foreignfuturedroppedcallback
+  // Implementation of free callback function CallbackInterfaceFree
+
+// Callback function:
+// uniffi::shim_uniffi::st::vtablecallbackinterfacefressheventlistener::vtablecallbackinterfacefressheventlistener::free::UniffiCallbackInterfaceFree
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::shim_uniffi::st::vtablecallbackinterfacefressheventlistener::
+    vtablecallbackinterfacefressheventlistener::free {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t)> rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue,
+                 uint64_t rs_handle) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_handle =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_handle);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_handle);
+
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback UniffiCallbackInterfaceFree: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static void callback(uint64_t rs_handle) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return;
+  }
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_handle);
+}
+
+[[maybe_unused]] static UniffiCallbackInterfaceFree
+makeCallbackFunction( // uniffi::shim_uniffi::st::vtablecallbackinterfacefressheventlistener::vtablecallbackinterfacefressheventlistener::free
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker, callbackValue](uint64_t rs_handle) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_handle](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_handle);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+
+    callInvoker->invokeNonBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeShimUniffi, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace
+  // uniffi::shim_uniffi::st::vtablecallbackinterfacefressheventlistener::vtablecallbackinterfacefressheventlistener::free
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureDroppedCallbackStruct> {
+  static UniffiForeignFutureDroppedCallbackStruct
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(
+          rt,
+          "Expected an object for UniffiForeignFutureDroppedCallbackStruct");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureDroppedCallbackStruct rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.handle = uniffi_jsi::Bridging<uint64_t>::fromJs(
+        rt, callInvoker, jsObject.getProperty(rt, "handle"));
+    rsObject.free = uniffi::shim_uniffi::cb::foreignfuturedroppedcallback::
+        makeCallbackFunction(rt, callInvoker, jsObject.getProperty(rt, "free"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureResultU8> {
+  static UniffiForeignFutureResultU8
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(rt,
+                         "Expected an object for UniffiForeignFutureResultU8");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureResultU8 rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.return_value = uniffi_jsi::Bridging<uint8_t>::fromJs(
+        rt, callInvoker, jsObject.getProperty(rt, "return_value"));
+    rsObject.call_status =
+        uniffi::shim_uniffi::Bridging<RustCallStatus>::fromJs(
+            rt, callInvoker, jsObject.getProperty(rt, "call_status"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+  // Implementation of callback function calling from JS to Rust
+  // ForeignFutureCompleteU8, passed from Rust to JS as part of async callbacks.
+namespace uniffi::shim_uniffi {
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureCompleteU8> {
+  static jsi::Value toJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         UniffiForeignFutureCompleteU8 rsCallback) {
+    return jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "--ForeignFutureCompleteU8"), 2,
+        [rsCallback, callInvoker](jsi::Runtime &rt, const jsi::Value &thisValue,
+                                  const jsi::Value *arguments,
+                                  size_t count) -> jsi::Value {
+          return intoRust(rt, callInvoker, thisValue, arguments, count,
+                          rsCallback);
+        });
+  }
+
+  static jsi::Value intoRust(jsi::Runtime &rt,
+                             std::shared_ptr<CallInvoker> callInvoker,
+                             const jsi::Value &thisValue,
+                             const jsi::Value *args, size_t count,
+                             UniffiForeignFutureCompleteU8 func) {
+    // Convert the arguments into the Rust, with Bridging<T>::fromJs,
+    // then call the rs_callback with those arguments.
+    func(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]),
+         uniffi::shim_uniffi::Bridging<UniffiForeignFutureResultU8>::fromJs(
+             rt, callInvoker, args[1]));
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureResultI8> {
+  static UniffiForeignFutureResultI8
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(rt,
+                         "Expected an object for UniffiForeignFutureResultI8");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureResultI8 rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.return_value = uniffi_jsi::Bridging<int8_t>::fromJs(
+        rt, callInvoker, jsObject.getProperty(rt, "return_value"));
+    rsObject.call_status =
+        uniffi::shim_uniffi::Bridging<RustCallStatus>::fromJs(
+            rt, callInvoker, jsObject.getProperty(rt, "call_status"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+  // Implementation of callback function calling from JS to Rust
+  // ForeignFutureCompleteI8, passed from Rust to JS as part of async callbacks.
+namespace uniffi::shim_uniffi {
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureCompleteI8> {
+  static jsi::Value toJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         UniffiForeignFutureCompleteI8 rsCallback) {
+    return jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "--ForeignFutureCompleteI8"), 2,
+        [rsCallback, callInvoker](jsi::Runtime &rt, const jsi::Value &thisValue,
+                                  const jsi::Value *arguments,
+                                  size_t count) -> jsi::Value {
+          return intoRust(rt, callInvoker, thisValue, arguments, count,
+                          rsCallback);
+        });
+  }
+
+  static jsi::Value intoRust(jsi::Runtime &rt,
+                             std::shared_ptr<CallInvoker> callInvoker,
+                             const jsi::Value &thisValue,
+                             const jsi::Value *args, size_t count,
+                             UniffiForeignFutureCompleteI8 func) {
+    // Convert the arguments into the Rust, with Bridging<T>::fromJs,
+    // then call the rs_callback with those arguments.
+    func(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]),
+         uniffi::shim_uniffi::Bridging<UniffiForeignFutureResultI8>::fromJs(
+             rt, callInvoker, args[1]));
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureResultU16> {
+  static UniffiForeignFutureResultU16
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(rt,
+                         "Expected an object for UniffiForeignFutureResultU16");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureResultU16 rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.return_value = uniffi_jsi::Bridging<uint16_t>::fromJs(
+        rt, callInvoker, jsObject.getProperty(rt, "return_value"));
+    rsObject.call_status =
+        uniffi::shim_uniffi::Bridging<RustCallStatus>::fromJs(
+            rt, callInvoker, jsObject.getProperty(rt, "call_status"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+  // Implementation of callback function calling from JS to Rust
+  // ForeignFutureCompleteU16, passed from Rust to JS as part of async
+  // callbacks.
+namespace uniffi::shim_uniffi {
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureCompleteU16> {
+  static jsi::Value toJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         UniffiForeignFutureCompleteU16 rsCallback) {
+    return jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "--ForeignFutureCompleteU16"), 2,
+        [rsCallback, callInvoker](jsi::Runtime &rt, const jsi::Value &thisValue,
+                                  const jsi::Value *arguments,
+                                  size_t count) -> jsi::Value {
+          return intoRust(rt, callInvoker, thisValue, arguments, count,
+                          rsCallback);
+        });
+  }
+
+  static jsi::Value intoRust(jsi::Runtime &rt,
+                             std::shared_ptr<CallInvoker> callInvoker,
+                             const jsi::Value &thisValue,
+                             const jsi::Value *args, size_t count,
+                             UniffiForeignFutureCompleteU16 func) {
+    // Convert the arguments into the Rust, with Bridging<T>::fromJs,
+    // then call the rs_callback with those arguments.
+    func(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]),
+         uniffi::shim_uniffi::Bridging<UniffiForeignFutureResultU16>::fromJs(
+             rt, callInvoker, args[1]));
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureResultI16> {
+  static UniffiForeignFutureResultI16
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(rt,
+                         "Expected an object for UniffiForeignFutureResultI16");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureResultI16 rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.return_value = uniffi_jsi::Bridging<int16_t>::fromJs(
+        rt, callInvoker, jsObject.getProperty(rt, "return_value"));
+    rsObject.call_status =
+        uniffi::shim_uniffi::Bridging<RustCallStatus>::fromJs(
+            rt, callInvoker, jsObject.getProperty(rt, "call_status"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+  // Implementation of callback function calling from JS to Rust
+  // ForeignFutureCompleteI16, passed from Rust to JS as part of async
+  // callbacks.
+namespace uniffi::shim_uniffi {
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureCompleteI16> {
+  static jsi::Value toJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         UniffiForeignFutureCompleteI16 rsCallback) {
+    return jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "--ForeignFutureCompleteI16"), 2,
+        [rsCallback, callInvoker](jsi::Runtime &rt, const jsi::Value &thisValue,
+                                  const jsi::Value *arguments,
+                                  size_t count) -> jsi::Value {
+          return intoRust(rt, callInvoker, thisValue, arguments, count,
+                          rsCallback);
+        });
+  }
+
+  static jsi::Value intoRust(jsi::Runtime &rt,
+                             std::shared_ptr<CallInvoker> callInvoker,
+                             const jsi::Value &thisValue,
+                             const jsi::Value *args, size_t count,
+                             UniffiForeignFutureCompleteI16 func) {
+    // Convert the arguments into the Rust, with Bridging<T>::fromJs,
+    // then call the rs_callback with those arguments.
+    func(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]),
+         uniffi::shim_uniffi::Bridging<UniffiForeignFutureResultI16>::fromJs(
+             rt, callInvoker, args[1]));
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureResultU32> {
+  static UniffiForeignFutureResultU32
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(rt,
+                         "Expected an object for UniffiForeignFutureResultU32");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureResultU32 rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.return_value = uniffi_jsi::Bridging<uint32_t>::fromJs(
+        rt, callInvoker, jsObject.getProperty(rt, "return_value"));
+    rsObject.call_status =
+        uniffi::shim_uniffi::Bridging<RustCallStatus>::fromJs(
+            rt, callInvoker, jsObject.getProperty(rt, "call_status"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+  // Implementation of callback function calling from JS to Rust
+  // ForeignFutureCompleteU32, passed from Rust to JS as part of async
+  // callbacks.
+namespace uniffi::shim_uniffi {
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureCompleteU32> {
+  static jsi::Value toJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         UniffiForeignFutureCompleteU32 rsCallback) {
+    return jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "--ForeignFutureCompleteU32"), 2,
+        [rsCallback, callInvoker](jsi::Runtime &rt, const jsi::Value &thisValue,
+                                  const jsi::Value *arguments,
+                                  size_t count) -> jsi::Value {
+          return intoRust(rt, callInvoker, thisValue, arguments, count,
+                          rsCallback);
+        });
+  }
+
+  static jsi::Value intoRust(jsi::Runtime &rt,
+                             std::shared_ptr<CallInvoker> callInvoker,
+                             const jsi::Value &thisValue,
+                             const jsi::Value *args, size_t count,
+                             UniffiForeignFutureCompleteU32 func) {
+    // Convert the arguments into the Rust, with Bridging<T>::fromJs,
+    // then call the rs_callback with those arguments.
+    func(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]),
+         uniffi::shim_uniffi::Bridging<UniffiForeignFutureResultU32>::fromJs(
+             rt, callInvoker, args[1]));
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureResultI32> {
+  static UniffiForeignFutureResultI32
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(rt,
+                         "Expected an object for UniffiForeignFutureResultI32");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureResultI32 rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.return_value = uniffi_jsi::Bridging<int32_t>::fromJs(
+        rt, callInvoker, jsObject.getProperty(rt, "return_value"));
+    rsObject.call_status =
+        uniffi::shim_uniffi::Bridging<RustCallStatus>::fromJs(
+            rt, callInvoker, jsObject.getProperty(rt, "call_status"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+  // Implementation of callback function calling from JS to Rust
+  // ForeignFutureCompleteI32, passed from Rust to JS as part of async
+  // callbacks.
+namespace uniffi::shim_uniffi {
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureCompleteI32> {
+  static jsi::Value toJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         UniffiForeignFutureCompleteI32 rsCallback) {
+    return jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "--ForeignFutureCompleteI32"), 2,
+        [rsCallback, callInvoker](jsi::Runtime &rt, const jsi::Value &thisValue,
+                                  const jsi::Value *arguments,
+                                  size_t count) -> jsi::Value {
+          return intoRust(rt, callInvoker, thisValue, arguments, count,
+                          rsCallback);
+        });
+  }
+
+  static jsi::Value intoRust(jsi::Runtime &rt,
+                             std::shared_ptr<CallInvoker> callInvoker,
+                             const jsi::Value &thisValue,
+                             const jsi::Value *args, size_t count,
+                             UniffiForeignFutureCompleteI32 func) {
+    // Convert the arguments into the Rust, with Bridging<T>::fromJs,
+    // then call the rs_callback with those arguments.
+    func(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]),
+         uniffi::shim_uniffi::Bridging<UniffiForeignFutureResultI32>::fromJs(
+             rt, callInvoker, args[1]));
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureResultU64> {
+  static UniffiForeignFutureResultU64
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(rt,
+                         "Expected an object for UniffiForeignFutureResultU64");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureResultU64 rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.return_value = uniffi_jsi::Bridging<uint64_t>::fromJs(
+        rt, callInvoker, jsObject.getProperty(rt, "return_value"));
+    rsObject.call_status =
+        uniffi::shim_uniffi::Bridging<RustCallStatus>::fromJs(
+            rt, callInvoker, jsObject.getProperty(rt, "call_status"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+  // Implementation of callback function calling from JS to Rust
+  // ForeignFutureCompleteU64, passed from Rust to JS as part of async
+  // callbacks.
+namespace uniffi::shim_uniffi {
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureCompleteU64> {
+  static jsi::Value toJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         UniffiForeignFutureCompleteU64 rsCallback) {
+    return jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "--ForeignFutureCompleteU64"), 2,
+        [rsCallback, callInvoker](jsi::Runtime &rt, const jsi::Value &thisValue,
+                                  const jsi::Value *arguments,
+                                  size_t count) -> jsi::Value {
+          return intoRust(rt, callInvoker, thisValue, arguments, count,
+                          rsCallback);
+        });
+  }
+
+  static jsi::Value intoRust(jsi::Runtime &rt,
+                             std::shared_ptr<CallInvoker> callInvoker,
+                             const jsi::Value &thisValue,
+                             const jsi::Value *args, size_t count,
+                             UniffiForeignFutureCompleteU64 func) {
+    // Convert the arguments into the Rust, with Bridging<T>::fromJs,
+    // then call the rs_callback with those arguments.
+    func(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]),
+         uniffi::shim_uniffi::Bridging<UniffiForeignFutureResultU64>::fromJs(
+             rt, callInvoker, args[1]));
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureResultI64> {
+  static UniffiForeignFutureResultI64
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(rt,
+                         "Expected an object for UniffiForeignFutureResultI64");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureResultI64 rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.return_value = uniffi_jsi::Bridging<int64_t>::fromJs(
+        rt, callInvoker, jsObject.getProperty(rt, "return_value"));
+    rsObject.call_status =
+        uniffi::shim_uniffi::Bridging<RustCallStatus>::fromJs(
+            rt, callInvoker, jsObject.getProperty(rt, "call_status"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+  // Implementation of callback function calling from JS to Rust
+  // ForeignFutureCompleteI64, passed from Rust to JS as part of async
+  // callbacks.
+namespace uniffi::shim_uniffi {
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureCompleteI64> {
+  static jsi::Value toJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         UniffiForeignFutureCompleteI64 rsCallback) {
+    return jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "--ForeignFutureCompleteI64"), 2,
+        [rsCallback, callInvoker](jsi::Runtime &rt, const jsi::Value &thisValue,
+                                  const jsi::Value *arguments,
+                                  size_t count) -> jsi::Value {
+          return intoRust(rt, callInvoker, thisValue, arguments, count,
+                          rsCallback);
+        });
+  }
+
+  static jsi::Value intoRust(jsi::Runtime &rt,
+                             std::shared_ptr<CallInvoker> callInvoker,
+                             const jsi::Value &thisValue,
+                             const jsi::Value *args, size_t count,
+                             UniffiForeignFutureCompleteI64 func) {
+    // Convert the arguments into the Rust, with Bridging<T>::fromJs,
+    // then call the rs_callback with those arguments.
+    func(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]),
+         uniffi::shim_uniffi::Bridging<UniffiForeignFutureResultI64>::fromJs(
+             rt, callInvoker, args[1]));
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureResultF32> {
+  static UniffiForeignFutureResultF32
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(rt,
+                         "Expected an object for UniffiForeignFutureResultF32");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureResultF32 rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.return_value = uniffi_jsi::Bridging<float>::fromJs(
+        rt, callInvoker, jsObject.getProperty(rt, "return_value"));
+    rsObject.call_status =
+        uniffi::shim_uniffi::Bridging<RustCallStatus>::fromJs(
+            rt, callInvoker, jsObject.getProperty(rt, "call_status"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+  // Implementation of callback function calling from JS to Rust
+  // ForeignFutureCompleteF32, passed from Rust to JS as part of async
+  // callbacks.
+namespace uniffi::shim_uniffi {
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureCompleteF32> {
+  static jsi::Value toJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         UniffiForeignFutureCompleteF32 rsCallback) {
+    return jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "--ForeignFutureCompleteF32"), 2,
+        [rsCallback, callInvoker](jsi::Runtime &rt, const jsi::Value &thisValue,
+                                  const jsi::Value *arguments,
+                                  size_t count) -> jsi::Value {
+          return intoRust(rt, callInvoker, thisValue, arguments, count,
+                          rsCallback);
+        });
+  }
+
+  static jsi::Value intoRust(jsi::Runtime &rt,
+                             std::shared_ptr<CallInvoker> callInvoker,
+                             const jsi::Value &thisValue,
+                             const jsi::Value *args, size_t count,
+                             UniffiForeignFutureCompleteF32 func) {
+    // Convert the arguments into the Rust, with Bridging<T>::fromJs,
+    // then call the rs_callback with those arguments.
+    func(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]),
+         uniffi::shim_uniffi::Bridging<UniffiForeignFutureResultF32>::fromJs(
+             rt, callInvoker, args[1]));
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureResultF64> {
+  static UniffiForeignFutureResultF64
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(rt,
+                         "Expected an object for UniffiForeignFutureResultF64");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureResultF64 rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.return_value = uniffi_jsi::Bridging<double>::fromJs(
+        rt, callInvoker, jsObject.getProperty(rt, "return_value"));
+    rsObject.call_status =
+        uniffi::shim_uniffi::Bridging<RustCallStatus>::fromJs(
+            rt, callInvoker, jsObject.getProperty(rt, "call_status"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+  // Implementation of callback function calling from JS to Rust
+  // ForeignFutureCompleteF64, passed from Rust to JS as part of async
+  // callbacks.
+namespace uniffi::shim_uniffi {
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureCompleteF64> {
+  static jsi::Value toJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         UniffiForeignFutureCompleteF64 rsCallback) {
+    return jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "--ForeignFutureCompleteF64"), 2,
+        [rsCallback, callInvoker](jsi::Runtime &rt, const jsi::Value &thisValue,
+                                  const jsi::Value *arguments,
+                                  size_t count) -> jsi::Value {
+          return intoRust(rt, callInvoker, thisValue, arguments, count,
+                          rsCallback);
+        });
+  }
+
+  static jsi::Value intoRust(jsi::Runtime &rt,
+                             std::shared_ptr<CallInvoker> callInvoker,
+                             const jsi::Value &thisValue,
+                             const jsi::Value *args, size_t count,
+                             UniffiForeignFutureCompleteF64 func) {
+    // Convert the arguments into the Rust, with Bridging<T>::fromJs,
+    // then call the rs_callback with those arguments.
+    func(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]),
+         uniffi::shim_uniffi::Bridging<UniffiForeignFutureResultF64>::fromJs(
+             rt, callInvoker, args[1]));
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureResultRustBuffer> {
+  static UniffiForeignFutureResultRustBuffer
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(
+          rt, "Expected an object for UniffiForeignFutureResultRustBuffer");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureResultRustBuffer rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.return_value = uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(
+        rt, callInvoker, jsObject.getProperty(rt, "return_value"));
+    rsObject.call_status =
+        uniffi::shim_uniffi::Bridging<RustCallStatus>::fromJs(
+            rt, callInvoker, jsObject.getProperty(rt, "call_status"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+  // Implementation of callback function calling from JS to Rust
+  // ForeignFutureCompleteRustBuffer, passed from Rust to JS as part of async
+  // callbacks.
+namespace uniffi::shim_uniffi {
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureCompleteRustBuffer> {
+  static jsi::Value toJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         UniffiForeignFutureCompleteRustBuffer rsCallback) {
+    return jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "--ForeignFutureCompleteRustBuffer"),
+        2,
+        [rsCallback, callInvoker](jsi::Runtime &rt, const jsi::Value &thisValue,
+                                  const jsi::Value *arguments,
+                                  size_t count) -> jsi::Value {
+          return intoRust(rt, callInvoker, thisValue, arguments, count,
+                          rsCallback);
+        });
+  }
+
+  static jsi::Value intoRust(jsi::Runtime &rt,
+                             std::shared_ptr<CallInvoker> callInvoker,
+                             const jsi::Value &thisValue,
+                             const jsi::Value *args, size_t count,
+                             UniffiForeignFutureCompleteRustBuffer func) {
+    // Convert the arguments into the Rust, with Bridging<T>::fromJs,
+    // then call the rs_callback with those arguments.
+    func(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]),
+         uniffi::shim_uniffi::Bridging<
+             UniffiForeignFutureResultRustBuffer>::fromJs(rt, callInvoker,
+                                                          args[1]));
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace uniffi::shim_uniffi
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureResultVoid> {
+  static UniffiForeignFutureResultVoid
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(
+          rt, "Expected an object for UniffiForeignFutureResultVoid");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiForeignFutureResultVoid rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.call_status =
+        uniffi::shim_uniffi::Bridging<RustCallStatus>::fromJs(
+            rt, callInvoker, jsObject.getProperty(rt, "call_status"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+  // Implementation of callback function calling from JS to Rust
+  // ForeignFutureCompleteVoid, passed from Rust to JS as part of async
+  // callbacks.
+namespace uniffi::shim_uniffi {
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiForeignFutureCompleteVoid> {
+  static jsi::Value toJs(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> callInvoker,
+                         UniffiForeignFutureCompleteVoid rsCallback) {
+    return jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "--ForeignFutureCompleteVoid"), 2,
+        [rsCallback, callInvoker](jsi::Runtime &rt, const jsi::Value &thisValue,
+                                  const jsi::Value *arguments,
+                                  size_t count) -> jsi::Value {
+          return intoRust(rt, callInvoker, thisValue, arguments, count,
+                          rsCallback);
+        });
+  }
+
+  static jsi::Value intoRust(jsi::Runtime &rt,
+                             std::shared_ptr<CallInvoker> callInvoker,
+                             const jsi::Value &thisValue,
+                             const jsi::Value *args, size_t count,
+                             UniffiForeignFutureCompleteVoid func) {
+    // Convert the arguments into the Rust, with Bridging<T>::fromJs,
+    // then call the rs_callback with those arguments.
+    func(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]),
+         uniffi::shim_uniffi::Bridging<UniffiForeignFutureResultVoid>::fromJs(
+             rt, callInvoker, args[1]));
+
+    return jsi::Value::undefined();
+  }
+};
+} // namespace uniffi::shim_uniffi
+  // Implementation of CallbackInterfaceClone for vtable field uniffi_clone in
+  // VTableCallbackInterfaceFresshEventListener
+
+// Callback function:
+// uniffi::shim_uniffi::cb::callbackinterfaceclone::vtablecallbackinterfacefressheventlistener::UniffiCallbackInterfaceClone
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::shim_uniffi::cb::callbackinterfaceclone::
+    vtablecallbackinterfacefressheventlistener {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t, uint64_t *)> rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue, uint64_t rs_handle,
+                 uint64_t *uniffi_direct_return) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_handle =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_handle);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_handle);
+
+    // Write the direct return value back to the caller.
+    if (uniffi_direct_return != nullptr) {
+      *uniffi_direct_return =
+          uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, uniffiResult);
+    }
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback UniffiCallbackInterfaceClone: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static uint64_t callback(uint64_t rs_handle) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return 0;
+  }
+  uint64_t uniffi_result = 0;
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_handle, &uniffi_result);
+  return uniffi_result;
+}
+
+[[maybe_unused]] static UniffiCallbackInterfaceClone
+makeCallbackFunction( // uniffi::shim_uniffi::cb::callbackinterfaceclone::vtablecallbackinterfacefressheventlistener
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker, callbackValue](uint64_t rs_handle,
+                                               uint64_t *uniffi_direct_return) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_handle,
+         uniffi_direct_return](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_handle, uniffi_direct_return);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+    callInvoker->invokeBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeShimUniffi, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace
+  // uniffi::shim_uniffi::cb::callbackinterfaceclone::vtablecallbackinterfacefressheventlistener
+  // Implementation of CallbackInterfaceFresshEventListenerMethod0 for vtable
+  // field on_event in VTableCallbackInterfaceFresshEventListener
+
+// Callback function:
+// uniffi::shim_uniffi::cb::callbackinterfacefressheventlistenermethod0::vtablecallbackinterfacefressheventlistener::UniffiCallbackInterfaceFresshEventListenerMethod0
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::shim_uniffi::cb::callbackinterfacefressheventlistenermethod0::
+    vtablecallbackinterfacefressheventlistener {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t, RustBuffer, void *, RustCallStatus *)>
+    rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_event,
+                 void *rs_uniffiOutReturn, RustCallStatus *uniffi_call_status) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_uniffiHandle =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_uniffiHandle);
+  auto js_event = uniffi::shim_uniffi::Bridging<RustBuffer>::toJs(
+      rt, callInvoker, rs_event);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_event);
+
+    // Now copy the result back from JS into the RustCallStatus object.
+    uniffi::shim_uniffi::Bridging<RustCallStatus>::copyFromJs(
+        rt, callInvoker, uniffiResult, uniffi_call_status);
+
+    if (uniffi_call_status->code != UNIFFI_CALL_STATUS_OK) {
+      // The JS callback finished abnormally, so we cannot retrieve the return
+      // value.
+      return;
+    }
+
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback "
+                 "UniffiCallbackInterfaceFresshEventListenerMethod0: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static void callback(uint64_t rs_uniffiHandle, RustBuffer rs_event,
+                     void *rs_uniffiOutReturn,
+                     RustCallStatus *uniffi_call_status) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return;
+  }
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_uniffiHandle, rs_event, rs_uniffiOutReturn, uniffi_call_status);
+}
+
+[[maybe_unused]] static UniffiCallbackInterfaceFresshEventListenerMethod0
+makeCallbackFunction( // uniffi::shim_uniffi::cb::callbackinterfacefressheventlistenermethod0::vtablecallbackinterfacefressheventlistener
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker, callbackValue](
+                 uint64_t rs_uniffiHandle, RustBuffer rs_event,
+                 void *rs_uniffiOutReturn, RustCallStatus *uniffi_call_status) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_uniffiHandle, rs_event,
+         rs_uniffiOutReturn, uniffi_call_status](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_event,
+               rs_uniffiOutReturn, uniffi_call_status);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+    callInvoker->invokeBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeShimUniffi, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace
+  // uniffi::shim_uniffi::cb::callbackinterfacefressheventlistenermethod0::vtablecallbackinterfacefressheventlistener
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiVTableCallbackInterfaceFresshEventListener> {
+  static UniffiVTableCallbackInterfaceFresshEventListener
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(rt,
+                         "Expected an object for "
+                         "UniffiVTableCallbackInterfaceFresshEventListener");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiVTableCallbackInterfaceFresshEventListener rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.uniffi_free =
+        uniffi::shim_uniffi::st::vtablecallbackinterfacefressheventlistener::
+            vtablecallbackinterfacefressheventlistener::free::
+                makeCallbackFunction(rt, callInvoker,
+                                     jsObject.getProperty(rt, "uniffi_free"));
+    rsObject.uniffi_clone = uniffi::shim_uniffi::cb::callbackinterfaceclone::
+        vtablecallbackinterfacefressheventlistener::makeCallbackFunction(
+            rt, callInvoker, jsObject.getProperty(rt, "uniffi_clone"));
+    rsObject.on_event =
+        uniffi::shim_uniffi::cb::callbackinterfacefressheventlistenermethod0::
+            vtablecallbackinterfacefressheventlistener::makeCallbackFunction(
+                rt, callInvoker, jsObject.getProperty(rt, "on_event"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+
+namespace uniffi::shim_uniffi {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiRustFutureContinuationCallback> {
+  static UniffiRustFutureContinuationCallback
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &value) {
+    try {
+      return uniffi::shim_uniffi::cb::rustfuturecontinuationcallback::
+          makeCallbackFunction(rt, callInvoker, value);
+    } catch (const std::logic_error &e) {
+      throw jsi::JSError(rt, e.what());
+    }
+  }
+};
+
+} // namespace uniffi::shim_uniffi
+
+NativeShimUniffi::NativeShimUniffi(
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> invoker)
+    : callInvoker(invoker), props() {
+  // Map from Javascript names to the cpp names
+  props["ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_internal_fn_func_ffi__string_to_byte_length(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_internal_fn_func_ffi__string_to_buffer"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_internal_fn_func_ffi__string_to_buffer"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_internal_fn_func_ffi__string_to_buffer(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_internal_fn_func_ffi__string_from_buffer"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_internal_fn_func_ffi__string_from_buffer"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_internal_fn_func_ffi__string_from_buffer(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_internal_fn_func_ffi__read_string_from_buffer"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_internal_fn_func_ffi__read_string_from_buffer"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this
+                ->cpp_uniffi_internal_fn_func_ffi__read_string_from_buffer(
+                    rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_clone_fressheventlistener"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_clone_fressheventlistener"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_clone_fressheventlistener(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_free_fressheventlistener"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_free_fressheventlistener"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_free_fressheventlistener(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_init_callback_vtable_fressheventlistener"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, "ubrn_uniffi_shim_uniffi_fn_init_"
+                                        "callback_vtable_fressheventlistener"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this
+                ->cpp_uniffi_shim_uniffi_fn_init_callback_vtable_fressheventlistener(
+                    rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_method_fressheventlistener_on_event"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt,
+              "ubrn_uniffi_shim_uniffi_fn_method_fressheventlistener_on_event"),
+          2,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this
+                ->cpp_uniffi_shim_uniffi_fn_method_fressheventlistener_on_event(
+                    rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_close_preview"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_close_preview"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_close_preview(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_close_shell"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_close_shell"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_close_shell(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_connect"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt,
+                                    "ubrn_uniffi_shim_uniffi_fn_func_connect"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_connect(rt, thisVal,
+                                                                args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_create_preview"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_create_preview"),
+          2,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_create_preview(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_disconnect"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_disconnect"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_disconnect(rt, thisVal,
+                                                                   args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_generate_key_pair"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_generate_key_pair"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_generate_key_pair(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_resize"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt,
+                                    "ubrn_uniffi_shim_uniffi_fn_func_resize"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_resize(rt, thisVal,
+                                                               args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_respond_to_host_key"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_respond_to_host_key"),
+          2,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_respond_to_host_key(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_run_command"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_run_command"),
+          2,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_run_command(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_scroll"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt,
+                                    "ubrn_uniffi_shim_uniffi_fn_func_scroll"),
+          2,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_scroll(rt, thisVal,
+                                                               args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_selection_clear"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_selection_clear"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_selection_clear(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_selection_start"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_selection_start"),
+          4,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_selection_start(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_selection_text"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_selection_text"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_selection_text(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_selection_update"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_selection_update"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_selection_update(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_send_data"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_send_data"),
+          2,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_send_data(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_set_event_listener"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_set_event_listener"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_set_event_listener(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_start_shell"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_start_shell"),
+          2,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_start_shell(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_fn_func_validate_private_key"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_fn_func_validate_private_key"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_fn_func_validate_private_key(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_poll_u8"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt,
+                                    "ubrn_ffi_shim_uniffi_rust_future_poll_u8"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_poll_u8(rt, thisVal,
+                                                                 args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_cancel_u8"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_cancel_u8"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_cancel_u8(rt, thisVal,
+                                                                   args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_free_u8"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt,
+                                    "ubrn_ffi_shim_uniffi_rust_future_free_u8"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_free_u8(rt, thisVal,
+                                                                 args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_complete_u8"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_complete_u8"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_complete_u8(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_poll_i8"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt,
+                                    "ubrn_ffi_shim_uniffi_rust_future_poll_i8"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_poll_i8(rt, thisVal,
+                                                                 args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_cancel_i8"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_cancel_i8"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_cancel_i8(rt, thisVal,
+                                                                   args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_free_i8"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt,
+                                    "ubrn_ffi_shim_uniffi_rust_future_free_i8"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_free_i8(rt, thisVal,
+                                                                 args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_complete_i8"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_complete_i8"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_complete_i8(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_poll_u16"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_poll_u16"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_poll_u16(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_cancel_u16"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_cancel_u16"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_cancel_u16(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_free_u16"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_free_u16"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_free_u16(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_complete_u16"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_complete_u16"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_complete_u16(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_poll_i16"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_poll_i16"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_poll_i16(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_cancel_i16"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_cancel_i16"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_cancel_i16(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_free_i16"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_free_i16"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_free_i16(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_complete_i16"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_complete_i16"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_complete_i16(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_poll_u32"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_poll_u32"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_poll_u32(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_cancel_u32"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_cancel_u32"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_cancel_u32(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_free_u32"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_free_u32"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_free_u32(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_complete_u32"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_complete_u32"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_complete_u32(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_poll_i32"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_poll_i32"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_poll_i32(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_cancel_i32"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_cancel_i32"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_cancel_i32(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_free_i32"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_free_i32"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_free_i32(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_complete_i32"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_complete_i32"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_complete_i32(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_poll_u64"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_poll_u64"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_poll_u64(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_cancel_u64"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_cancel_u64"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_cancel_u64(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_free_u64"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_free_u64"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_free_u64(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_complete_u64"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_complete_u64"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_complete_u64(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_poll_i64"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_poll_i64"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_poll_i64(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_cancel_i64"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_cancel_i64"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_cancel_i64(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_free_i64"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_free_i64"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_free_i64(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_complete_i64"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_complete_i64"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_complete_i64(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_poll_f32"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_poll_f32"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_poll_f32(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_cancel_f32"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_cancel_f32"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_cancel_f32(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_free_f32"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_free_f32"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_free_f32(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_complete_f32"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_complete_f32"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_complete_f32(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_poll_f64"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_poll_f64"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_poll_f64(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_cancel_f64"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_cancel_f64"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_cancel_f64(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_free_f64"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_free_f64"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_free_f64(rt, thisVal,
+                                                                  args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_complete_f64"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_complete_f64"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_complete_f64(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_poll_rust_buffer"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_poll_rust_buffer"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_poll_rust_buffer(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_cancel_rust_buffer"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_cancel_rust_buffer"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_cancel_rust_buffer(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_free_rust_buffer"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_free_rust_buffer"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_free_rust_buffer(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_complete_rust_buffer"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_complete_rust_buffer"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_complete_rust_buffer(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_poll_void"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_poll_void"),
+          3,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_poll_void(rt, thisVal,
+                                                                   args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_cancel_void"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_cancel_void"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_cancel_void(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_free_void"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_free_void"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_free_void(rt, thisVal,
+                                                                   args, count);
+          });
+  props["ubrn_ffi_shim_uniffi_rust_future_complete_void"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_rust_future_complete_void"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_rust_future_complete_void(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_close_preview"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_close_preview"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_close_preview(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_close_shell"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_close_shell"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_close_shell(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_connect"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_connect"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_connect(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_create_preview"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_create_preview"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_create_preview(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_disconnect"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_disconnect"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_disconnect(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_generate_key_pair"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_generate_key_pair"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_generate_key_pair(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_resize"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_resize"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_resize(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_respond_to_host_key"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_respond_to_host_key"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this
+                ->cpp_uniffi_shim_uniffi_checksum_func_respond_to_host_key(
+                    rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_run_command"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_run_command"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_run_command(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_scroll"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_scroll"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_scroll(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_selection_clear"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_selection_clear"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_selection_clear(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_selection_start"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_selection_start"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_selection_start(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_selection_text"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_selection_text"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_selection_text(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_selection_update"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_selection_update"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_selection_update(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_send_data"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_send_data"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_send_data(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_set_event_listener"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_set_event_listener"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this
+                ->cpp_uniffi_shim_uniffi_checksum_func_set_event_listener(
+                    rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_start_shell"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_start_shell"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_shim_uniffi_checksum_func_start_shell(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_func_validate_private_key"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_shim_uniffi_checksum_func_validate_private_key"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this
+                ->cpp_uniffi_shim_uniffi_checksum_func_validate_private_key(
+                    rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_shim_uniffi_checksum_method_fressheventlistener_on_"
+        "event"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "ubrn_uniffi_shim_uniffi_checksum_method_"
+                                    "fressheventlistener_on_event"),
+      0,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_shim_uniffi_checksum_method_fressheventlistener_on_event(
+                rt, thisVal, args, count);
+      });
+  props["ubrn_ffi_shim_uniffi_uniffi_contract_version"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_ffi_shim_uniffi_uniffi_contract_version"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_ffi_shim_uniffi_uniffi_contract_version(
+                rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_internal_fn_method_fressheventlistener_ffi__bless_"
+        "pointer"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "ubrn_uniffi_internal_fn_method_"
+                                    "fressheventlistener_ffi__bless_pointer"),
+      1,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_internal_fn_method_fressheventlistener_ffi__bless_pointer(
+                rt, thisVal, args, count);
+      });
+
+  // `rustbuffer_alloc(n)` -> Uint8Array view over Rust-owned memory of capacity
+  // `n`. `rustbuffer_free(view)` -> hands the underlying (ptr, capacity) back
+  // to the crate's `rustbuffer_free`. Together they let JS allocate buffers
+  // that the codegen-emitted lowering path can fill in place and ship to Rust
+  // without copying.
+  props["rustbuffer_alloc"] = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "rustbuffer_alloc"), 1,
+      [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+         size_t count) -> jsi::Value {
+        if (count < 1 || !args[0].isNumber()) {
+          throw jsi::JSError(rt, "rustbuffer_alloc expected a number argument");
+        }
+        double size = args[0].asNumber();
+        if (size < 0) {
+          throw jsi::JSError(rt, "rustbuffer_alloc: size must be non-negative");
+        }
+        if (size > INT32_MAX) {
+          throw jsi::JSError(rt, "rustbuffer_alloc: size exceeds INT32_MAX");
+        }
+        auto rb = uniffi::shim_uniffi::Bridging<RustBuffer>::rustbuffer_alloc(
+            static_cast<int32_t>(size));
+        if (rb.data == nullptr) {
+          throw jsi::JSError(rt,
+                             "rustbuffer_alloc failed: alloc returned null");
+        }
+        // Non-owning view over Rust-allocated memory; CMutableBuffer's
+        // destructor is the default and does not free `rb.data`. JS must call
+        // rustbuffer_free explicitly before dropping the reference.
+        auto payload = std::make_shared<uniffi_jsi::CMutableBuffer>(
+            rb.data, static_cast<size_t>(rb.capacity));
+        // Wrap as Uint8Array so JS can index/assign bytes directly.
+        return jsi::Value(rt, uniffi_jsi::arraybufferToUint8Array(
+                                  rt, jsi::ArrayBuffer(rt, payload)));
+      });
+
+  props["rustbuffer_free"] = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "rustbuffer_free"), 1,
+      [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+         size_t count) -> jsi::Value {
+        if (count < 1 || !args[0].isObject()) {
+          throw jsi::JSError(rt,
+                             "rustbuffer_free expected a Uint8Array argument");
+        }
+        auto view = args[0].asObject(rt);
+        auto byteLength =
+            static_cast<size_t>(view.getProperty(rt, "byteLength").asNumber());
+        // Empty views were never allocated by `rustbuffer_alloc`; nothing
+        // to free. Bail out before reading buffer/byteOffset/capacity to
+        // skip three JSI property traversals on the empty path.
+        if (byteLength == 0) {
+          return jsi::Value::undefined();
+        }
+        // Capacity resolution:
+        //   * For a view from `rustbuffer_alloc(n)`, `byteLength == n ==
+        //   capacity`,
+        //     and no `__ubrnRustCapacity` hint was set.
+        //   * For a view from a lift-handoff, the codegen-emitted
+        //     `Bridging<RustBuffer>::toJs` set `byteLength = len` and stashed
+        //     the original `capacity` on `__ubrnRustCapacity` whenever
+        //     `capacity != len`.
+        // So: prefer the hint, fall back to byteLength.
+        size_t capacity = byteLength;
+        if (view.hasProperty(rt, uniffi_jsi::kUbrnRustCapacity)) {
+          capacity = static_cast<size_t>(
+              view.getProperty(rt, uniffi_jsi::kUbrnRustCapacity).asNumber());
+        }
+        auto buffer = view.getPropertyAsObject(rt, "buffer").getArrayBuffer(rt);
+        auto byteOffset =
+            static_cast<size_t>(view.getProperty(rt, "byteOffset").asNumber());
+        // Honour byteOffset for safety (defensive; currently always 0).
+        RustBuffer rb{
+            .capacity = static_cast<uint64_t>(capacity),
+            .len = 0,
+            .data = buffer.data(rt) + byteOffset,
+        };
+        uniffi::shim_uniffi::Bridging<RustBuffer>::rustbuffer_free(rb);
+        return jsi::Value::undefined();
+      });
+}
+
+void NativeShimUniffi::registerModule(
+    jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> callInvoker) {
+  auto invoker =
+      std::make_shared<uniffi_runtime::UniffiCallInvoker>(callInvoker);
+  auto tm = std::make_shared<NativeShimUniffi>(rt, invoker);
+  auto obj = rt.global().createFromHostObject(rt, tm);
+  rt.global().setProperty(rt, "NativeShimUniffi", obj);
+}
+
+void NativeShimUniffi::unregisterModule(jsi::Runtime &rt) {
+  uniffi::shim_uniffi::registry::clearRegistry();
+}
+
+jsi::Value NativeShimUniffi::get(jsi::Runtime &rt,
+                                 const jsi::PropNameID &name) {
+  try {
+    return jsi::Value(rt, props.at(name.utf8(rt)));
+  } catch (std::out_of_range &) {
+    return jsi::Value::undefined();
+  }
+}
+
+std::vector<jsi::PropNameID>
+NativeShimUniffi::getPropertyNames(jsi::Runtime &rt) {
+  std::vector<jsi::PropNameID> rval;
+  for (auto &[key, value] : props) {
+    rval.push_back(jsi::PropNameID::forUtf8(rt, key));
+  }
+  return rval;
+}
+
+void NativeShimUniffi::set(jsi::Runtime &rt, const jsi::PropNameID &name,
+                           const jsi::Value &value) {
+  props.insert_or_assign(name.utf8(rt), &value);
+}
+
+NativeShimUniffi::~NativeShimUniffi() {
+  // Cleanup for callback function RustFutureContinuationCallback
+  uniffi::shim_uniffi::cb::rustfuturecontinuationcallback::cleanup();
+  // Cleanup for callback function ForeignFutureDroppedCallback
+  uniffi::shim_uniffi::cb::foreignfuturedroppedcallback::cleanup();
+  // Cleanup for "free" callback function CallbackInterfaceFree
+  uniffi::shim_uniffi::st::vtablecallbackinterfacefressheventlistener::
+      vtablecallbackinterfacefressheventlistener::free::cleanup();
+  uniffi::shim_uniffi::cb::callbackinterfaceclone::
+      vtablecallbackinterfacefressheventlistener::cleanup();
+  uniffi::shim_uniffi::cb::callbackinterfacefressheventlistenermethod0::
+      vtablecallbackinterfacefressheventlistener::cleanup();
+}
+
+// Utility functions for serialization/deserialization of strings.
+jsi::Value
+NativeShimUniffi::cpp_uniffi_internal_fn_func_ffi__string_to_byte_length(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  return uniffi_jsi::Bridging<std::string>::string_to_bytelength(rt, args[0]);
+}
+
+jsi::Value NativeShimUniffi::cpp_uniffi_internal_fn_func_ffi__string_to_buffer(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  return uniffi_jsi::Bridging<std::string>::string_to_buffer(rt, args[0]);
+}
+
+jsi::Value
+NativeShimUniffi::cpp_uniffi_internal_fn_func_ffi__string_from_buffer(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  return uniffi_jsi::Bridging<std::string>::string_from_buffer(rt, args[0]);
+}
+
+jsi::Value
+NativeShimUniffi::cpp_uniffi_internal_fn_func_ffi__read_string_from_buffer(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  return uniffi_jsi::Bridging<std::string>::read_string_from_buffer(
+      rt, args[0], args[1], args[2]);
+}
+jsi::Value NativeShimUniffi::
+    cpp_uniffi_internal_fn_method_fressheventlistener_ffi__bless_pointer(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto pointer =
+      uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]);
+  auto static destructor = [](uint64_t p) {
+    RustCallStatus status = {0};
+    uniffi_shim_uniffi_fn_free_fressheventlistener(p, &status);
+  };
+  auto ptrObj =
+      std::make_shared<uniffi_jsi::DestructibleObject>(pointer, destructor);
+  auto obj = jsi::Object::createFromHostObject(rt, ptrObj);
+  return jsi::Value(rt, obj);
+}
+
+// Methods calling directly into the uniffi generated C API of the Rust crate.
+jsi::Value
+NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_clone_fressheventlistener(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = uniffi_shim_uniffi_fn_clone_fressheventlistener(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_free_fressheventlistener(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  uniffi_shim_uniffi_fn_free_fressheventlistener(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::
+    cpp_uniffi_shim_uniffi_fn_init_callback_vtable_fressheventlistener(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto vtableInstance = uniffi::shim_uniffi::Bridging<
+      UniffiVTableCallbackInterfaceFresshEventListener>::fromJs(rt, callInvoker,
+                                                                args[0]);
+
+  std::lock_guard<std::mutex> lock(uniffi::shim_uniffi::registry::vtableMutex);
+  uniffi_shim_uniffi_fn_init_callback_vtable_fressheventlistener(
+      uniffi::shim_uniffi::registry::putTable(
+          "UniffiVTableCallbackInterfaceFresshEventListener", vtableInstance));
+  return jsi::Value::undefined();
+}
+jsi::Value
+NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_method_fressheventlistener_on_event(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  uniffi_shim_uniffi_fn_method_fressheventlistener_on_event(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_close_preview(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_fn_func_close_preview(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_close_shell(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_fn_func_close_shell(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_connect(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_fn_func_connect(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_create_preview(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  uniffi_shim_uniffi_fn_func_create_preview(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_disconnect(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_fn_func_disconnect(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_generate_key_pair(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = uniffi_shim_uniffi_fn_func_generate_key_pair(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi::shim_uniffi::Bridging<RustBuffer>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_resize(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_fn_func_resize(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi_jsi::Bridging<uint32_t>::fromJs(rt, callInvoker, args[1]),
+      uniffi_jsi::Bridging<uint32_t>::fromJs(rt, callInvoker, args[2]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_respond_to_host_key(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  uniffi_shim_uniffi_fn_func_respond_to_host_key(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi_jsi::Bridging<int8_t>::fromJs(rt, callInvoker, args[1]), &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_run_command(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_fn_func_run_command(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[1]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_scroll(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_fn_func_scroll(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi_jsi::Bridging<float>::fromJs(rt, callInvoker, args[1]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_selection_clear(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  uniffi_shim_uniffi_fn_func_selection_clear(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_selection_start(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  uniffi_shim_uniffi_fn_func_selection_start(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi_jsi::Bridging<float>::fromJs(rt, callInvoker, args[1]),
+      uniffi_jsi::Bridging<float>::fromJs(rt, callInvoker, args[2]),
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[3]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_selection_text(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = uniffi_shim_uniffi_fn_func_selection_text(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi::shim_uniffi::Bridging<RustBuffer>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_selection_update(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  uniffi_shim_uniffi_fn_func_selection_update(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi_jsi::Bridging<float>::fromJs(rt, callInvoker, args[1]),
+      uniffi_jsi::Bridging<float>::fromJs(rt, callInvoker, args[2]), &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_send_data(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_fn_func_send_data(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[1]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_set_event_listener(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  uniffi_shim_uniffi_fn_func_set_event_listener(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_start_shell(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_fn_func_start_shell(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[1]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value
+NativeShimUniffi::cpp_uniffi_shim_uniffi_fn_func_validate_private_key(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = uniffi_shim_uniffi_fn_func_validate_private_key(
+      uniffi::shim_uniffi::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi::shim_uniffi::Bridging<RustBuffer>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_poll_u8(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_poll_u8(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<
+          UniffiRustFutureContinuationCallback>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[2]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_cancel_u8(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_cancel_u8(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_free_u8(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_free_u8(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_complete_u8(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = ffi_shim_uniffi_rust_future_complete_u8(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging<uint8_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_poll_i8(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_poll_i8(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<
+          UniffiRustFutureContinuationCallback>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[2]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_cancel_i8(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_cancel_i8(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_free_i8(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_free_i8(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_complete_i8(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = ffi_shim_uniffi_rust_future_complete_i8(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging<int8_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_poll_u16(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_poll_u16(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<
+          UniffiRustFutureContinuationCallback>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[2]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_cancel_u16(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_cancel_u16(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_free_u16(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_free_u16(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_complete_u16(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = ffi_shim_uniffi_rust_future_complete_u16(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_poll_i16(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_poll_i16(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<
+          UniffiRustFutureContinuationCallback>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[2]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_cancel_i16(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_cancel_i16(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_free_i16(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_free_i16(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_complete_i16(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = ffi_shim_uniffi_rust_future_complete_i16(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging<int16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_poll_u32(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_poll_u32(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<
+          UniffiRustFutureContinuationCallback>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[2]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_cancel_u32(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_cancel_u32(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_free_u32(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_free_u32(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_complete_u32(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = ffi_shim_uniffi_rust_future_complete_u32(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging<uint32_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_poll_i32(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_poll_i32(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<
+          UniffiRustFutureContinuationCallback>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[2]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_cancel_i32(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_cancel_i32(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_free_i32(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_free_i32(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_complete_i32(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = ffi_shim_uniffi_rust_future_complete_i32(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging<int32_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_poll_u64(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_poll_u64(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<
+          UniffiRustFutureContinuationCallback>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[2]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_cancel_u64(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_cancel_u64(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_free_u64(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_free_u64(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_complete_u64(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = ffi_shim_uniffi_rust_future_complete_u64(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_poll_i64(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_poll_i64(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<
+          UniffiRustFutureContinuationCallback>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[2]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_cancel_i64(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_cancel_i64(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_free_i64(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_free_i64(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_complete_i64(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = ffi_shim_uniffi_rust_future_complete_i64(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging<int64_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_poll_f32(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_poll_f32(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<
+          UniffiRustFutureContinuationCallback>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[2]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_cancel_f32(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_cancel_f32(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_free_f32(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_free_f32(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_complete_f32(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = ffi_shim_uniffi_rust_future_complete_f32(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging<float>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_poll_f64(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_poll_f64(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<
+          UniffiRustFutureContinuationCallback>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[2]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_cancel_f64(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_cancel_f64(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_free_f64(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_free_f64(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_complete_f64(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = ffi_shim_uniffi_rust_future_complete_f64(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging<double>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_poll_rust_buffer(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_poll_rust_buffer(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<
+          UniffiRustFutureContinuationCallback>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[2]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_cancel_rust_buffer(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_cancel_rust_buffer(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_free_rust_buffer(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_free_rust_buffer(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value
+NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_complete_rust_buffer(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = ffi_shim_uniffi_rust_future_complete_rust_buffer(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi::shim_uniffi::Bridging<RustBuffer>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_poll_void(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_poll_void(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      uniffi::shim_uniffi::Bridging<
+          UniffiRustFutureContinuationCallback>::fromJs(rt, callInvoker,
+                                                        args[1]),
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[2]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_cancel_void(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_cancel_void(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_free_void(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  ffi_shim_uniffi_rust_future_free_void(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]));
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_rust_future_complete_void(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::shim_uniffi::Bridging<RustCallStatus>::rustSuccess(rt);
+  ffi_shim_uniffi_rust_future_complete_void(
+      uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker,
+                                                        args[0]),
+      &status);
+  uniffi::shim_uniffi::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_close_preview(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_close_preview();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_close_shell(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_close_shell();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_connect(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_connect();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value
+NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_create_preview(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_create_preview();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_disconnect(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_disconnect();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value
+NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_generate_key_pair(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_generate_key_pair();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_resize(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_resize();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value
+NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_respond_to_host_key(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_respond_to_host_key();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_run_command(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_run_command();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_scroll(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_scroll();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value
+NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_selection_clear(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_selection_clear();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value
+NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_selection_start(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_selection_start();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value
+NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_selection_text(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_selection_text();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value
+NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_selection_update(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_selection_update();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_send_data(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_send_data();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value
+NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_set_event_listener(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_set_event_listener();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_start_shell(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_start_shell();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value
+NativeShimUniffi::cpp_uniffi_shim_uniffi_checksum_func_validate_private_key(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = uniffi_shim_uniffi_checksum_func_validate_private_key();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::
+    cpp_uniffi_shim_uniffi_checksum_method_fressheventlistener_on_event(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_shim_uniffi_checksum_method_fressheventlistener_on_event();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeShimUniffi::cpp_ffi_shim_uniffi_uniffi_contract_version(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  auto value = ffi_shim_uniffi_uniffi_contract_version();
+
+  return uniffi_jsi::Bridging<uint32_t>::toJs(rt, callInvoker, value);
+}