@shamilovtim/react-native-nitro-sse 2.3.0

package/lib/typescript/src/SseInterface.d.ts

@@ -0,0 +1,237 @@
+import type { AnyMap } from 'react-native-nitro-modules';
+/**
+ * HTTP method to use for the SSE connection.
+ */
+export type HttpMethod = 'get' | 'post';
+/**
+ * Type of event received from the SSE stream.
+ * - `open`: Connection established.
+ * - `message`: Standard data message.
+ * - `error`: Connection error or other failure.
+ * - `close`: Connection closed (not typical for SSE, but used for cleanup).
+ * - `heartbeat`: Ping/Keep-alive signal.
+ */
+export type SseEventType = 'open' | 'message' | 'error' | 'close' | 'heartbeat';
+/**
+ * Configuration for the SSE connection.
+ */
+export interface SseConfig {
+    /** The URL of the SSE endpoint. */
+    url: string;
+    /** HTTP method (default: 'GET'). */
+    method?: HttpMethod;
+    /** Custom HTTP headers to include in the request. */
+    headers?: Record<string, string>;
+    /** Body for POST requests. */
+    body?: string;
+    /**
+     * Whether to continue processing events when the app is in the background.
+     * Note: On iOS, this uses background tasks which are limited in time by the OS.
+     * @default false
+     */
+    backgroundExecution?: boolean;
+    /**
+     * How long (in ms) to wait and group multiple events before sending them to the JS side.
+     * High-frequency streams should use this to reduce JS bridge overhead and improve UI performance.
+     * Set to 0 to deliver events immediately one-by-one.
+     * @default 0
+     */
+    batchingIntervalMs?: number;
+    /**
+     * Maximum number of events to keep in the native buffer before forcing a flush to JS,
+     * regardless of the `batchingIntervalMs`. Prevents memory pressure.
+     * @default 1000
+     */
+    maxBufferSize?: number;
+    /**
+     * Maximum time (in ms) to wait for the initial server connection and handshake to complete.
+     * Effectively the \"Connect Timeout\".
+     * @default 15000
+     */
+    connectionTimeoutMs?: number;
+    /**
+     * Maximum idle time (in ms) allowed between receiving data packets or heartbeats.
+     * If the server remains silent longer than this, the connection is considered stalled and will reconnect.
+     * Increase this for streams that transmit data infrequently.
+     * @default 300000
+     */
+    readTimeoutMs?: number;
+    /**
+     * Initial delay (in ms) for reconnection attempts.
+     * Subsequent attempts use exponential backoff.
+     * @default 1000
+     */
+    retryIntervalMs?: number;
+    /**
+     * Maximum delay (in ms) for reconnection attempts.
+     * @default 30000
+     */
+    maxRetryIntervalMs?: number;
+    /**
+     * Factor to randomize reconnection attempts (0.0 to 1.0).
+     * 0 means no jitter, 1.0 means up to 100% randomization.
+     * @default 0.5
+     */
+    jitterFactor?: number;
+    /**
+     * Maximum number of reconnection attempts before giving up.
+     * Use -1 for infinite (default), 0 to disable auto-reconnection.
+     * @default -1
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * Whether to automatically parse message data as JSON in a background native thread.
+     * If true, and parsing succeeds, the result will be available in the 'parsedData' field.
+     * @default false
+     */
+    autoParseJSON?: boolean;
+    /**
+     * Whether to automatically monitor network connectivity changes.
+     * If true, the client will proactively reconnect when switching networks (WiFi <-> Cellular)
+     * and pause/resume based on internet availability.
+     * @default true
+     */
+    monitorNetwork?: boolean;
+    /**
+     * Async interceptor called before every connection attempt (including auto-reconnects).
+     * Use this to refresh tokens or calculate dynamic headers.
+     * Note: This is protected by a native timeout to prevent the app from hanging.
+     */
+    onBeforeRequest?: () => Promise<Record<string, string>>;
+    /**
+     * Configuration for mock streaming data.
+     * Used for local testing and debugging.
+     */
+    mock?: SseMockConfig;
+}
+export type SseMockMode = 'replace' | 'inject';
+/**
+ * Represents a single mock SSE event configuration.
+ */
+export interface SseMockEvent {
+    /** The type of the event. */
+    type?: SseEventType;
+    /** The data payload of the event as a raw string. */
+    data?: string;
+    /** The parsed JSON data, if autoParseJSON is enabled and parsing succeeds. */
+    parsedData?: AnyMap;
+    /** The event ID, if provided. */
+    id?: string;
+    /** The event name, if provided (internal 'event' field in SSE). */
+    event?: string;
+    /** System message or error description. */
+    message?: string;
+    /** HTTP status code if applicable. */
+    statusCode?: number;
+    /** Server-requested retry delay in milliseconds. */
+    retry?: number;
+    /** Custom delay in milliseconds before this event is dispatched. */
+    delayMs?: number;
+}
+/**
+ * Configuration for mock streaming data.
+ */
+export interface SseMockConfig {
+    /**
+     * - 'replace': Simulates the stream completely in JavaScript without any native network connection.
+     * - 'inject': Establishes the real server connection and injects mock events alongside it.
+     */
+    mode: SseMockMode;
+    /**
+     * The list of mock events to be streamed.
+     */
+    data: SseMockEvent[];
+    /**
+     * The frequency at which mock events are dispatched.
+     * Represented in events per second.
+     * @default 1
+     */
+    eventsPerSecond?: number;
+    /**
+     * Whether to loop the mock stream indefinitely.
+     * @default false
+     */
+    loop?: boolean;
+    /**
+     * Probability of simulated connection drop/error events (0.0 to 1.0).
+     * @default 0
+     */
+    errorRate?: number;
+}
+/**
+ * Represents a single SSE event.
+ */
+export interface SseEvent {
+    /** The type of the event. */
+    type: SseEventType;
+    /** The data payload of the event as a raw string. */
+    data?: string;
+    /** The parsed JSON data, if autoParseJSON is enabled and parsing succeeds. */
+    parsedData?: AnyMap;
+    /** The event ID, if provided. */
+    id?: string;
+    /** The event name, if provided (internal 'event' field in SSE). */
+    event?: string;
+    /** System message or error description. */
+    message?: string;
+    /** HTTP status code if applicable. */
+    statusCode?: number;
+    /** Server-requested retry delay in milliseconds. */
+    retry?: number;
+}
+/**
+ * Statistics about the SSE connection.
+ */
+export interface SseStats {
+    /** Total bytes received so far. */
+    totalBytesReceived: number;
+    /** Number of times the connection has been re-established. */
+    reconnectCount: number;
+    /** Timestamp of the last error event. */
+    lastErrorTime?: number;
+    /** Error code of the last error. */
+    lastErrorCode?: string;
+}
+/**
+ * Listener for a specific SSE event.
+ */
+export type SseListener = (event: SseEvent) => void;
+/**
+ * Public interface for the NitroSse client, supporting typed event listeners.
+ */
+export interface SseClient {
+    /**
+     * Configure SSE and setup event callback.
+     * @param config The SSE configuration.
+     * @param onEvent Optional legacy batch callback for all events.
+     */
+    setup(config: SseConfig, onEvent?: (events: SseEvent[]) => void): void;
+    /**
+     * Register a listener for a specific event type ('message', 'open', etc.)
+     * or a custom SSE event name (from the 'event:' field).
+     */
+    addEventListener(type: string, listener: SseListener): void;
+    /**
+     * Unregister a listener.
+     */
+    removeEventListener(type: string, listener: SseListener): void;
+    /** Start the connection. */
+    start(): void;
+    /** Stop the connection. */
+    stop(): void;
+    /** Restart the connection (stop + start). */
+    restart(): void;
+    /** Force flush buffered events to JS. */
+    flush(): void;
+    /** Check if active. */
+    isConnected(): boolean;
+    /** Get stats. */
+    getStats(): SseStats;
+    /** Manually update headers. */
+    updateHeaders(headers: Record<string, string>): void;
+    /** Set last event ID. */
+    setLastProcessedId(id: string): void;
+    /** Manually inject a mock event into the stream (for testing/debugging). */
+    injectMockEvent(event: Partial<SseEvent>): void;
+}
+//# sourceMappingURL=SseInterface.d.ts.map

package/lib/typescript/src/SseInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SseInterface.d.ts","sourceRoot":"","sources":["../../../src/SseInterface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,CAAC;AAExC;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,GAAG,WAAW,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,mCAAmC;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,oCAAoC;IACpC,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,qDAAqD;IACrD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,8BAA8B;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACxD;;;OAGG;IACH,IAAI,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,6BAA6B;IAC7B,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,mEAAmE;IACnE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sCAAsC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,IAAI,EAAE,WAAW,CAAC;IAClB;;OAEG;IACH,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,6BAA6B;IAC7B,IAAI,EAAE,YAAY,CAAC;IACnB,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,mEAAmE;IACnE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sCAAsC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,mCAAmC;IACnC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,8DAA8D;IAC9D,cAAc,EAAE,MAAM,CAAC;IACvB,yCAAyC;IACzC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oCAAoC;IACpC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAEvE;;;OAGG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;IAE5D;;OAEG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;IAE/D,4BAA4B;IAC5B,KAAK,IAAI,IAAI,CAAC;IACd,2BAA2B;IAC3B,IAAI,IAAI,IAAI,CAAC;IACb,6CAA6C;IAC7C,OAAO,IAAI,IAAI,CAAC;IAChB,yCAAyC;IACzC,KAAK,IAAI,IAAI,CAAC;IACd,uBAAuB;IACvB,WAAW,IAAI,OAAO,CAAC;IACvB,iBAAiB;IACjB,QAAQ,IAAI,QAAQ,CAAC;IACrB,+BAA+B;IAC/B,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACrD,yBAAyB;IACzB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,4EAA4E;IAC5E,eAAe,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;CACjD"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,11 @@
+import type { SseClient } from './SseInterface';
+export * from './SseInterface';
+export * from './NitroSse.nitro';
+/**
+ * Creates a high-performance SSE client that supports typed event listeners (`addEventListener`) and legacy batching.
+ *
+ * @returns An SseClient instance wrapping the native NitroSse implementation.
+ * @throws If the native NitroSse module cannot be found. Ensure the library is linked and the app is built for iOS/Android.
+ */
+export declare function createNitroSse(): SseClient;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AAEjC;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,SAAS,CAgB1C"}

package/nitro.json

@@ -0,0 +1,23 @@
+{
+  "cxxNamespace": ["nitrosse"],
+  "ios": {
+    "iosModuleName": "NitroSse"
+  },
+  "android": {
+    "androidNamespace": ["nitrosse"],
+    "androidCxxLibName": "nitrosse"
+  },
+  "autolinking": {
+    "NitroSse": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "NitroSse"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "NitroSse"
+      }
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

package/nitrogen/generated/android/c++/JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____.hpp

@@ -0,0 +1,138 @@
+///
+/// JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include <unordered_map>
+#include <NitroModules/Promise.hpp>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include <NitroModules/JPromise.hpp>
+
+namespace margelo::nitro::nitrosse {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Promise<Promise<Map<String, String>>>`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____: public jni::JavaClass<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrosse/Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____` instance holds through JNI.
+     */
+    std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>> invoke() const {
+      static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("invoke");
+      auto __result = method(self());
+      return [&]() {
+        auto __promise = Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>::create();
+        __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+          auto __result = jni::static_ref_cast<JPromise::javaobject>(__boxedResult);
+          __promise->resolve([&]() {
+            auto __promise = Promise<std::unordered_map<std::string, std::string>>::create();
+            __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+              auto __result = jni::static_ref_cast<jni::JMap<jni::JString, jni::JString>>(__boxedResult);
+              __promise->resolve([&]() {
+                std::unordered_map<std::string, std::string> __map;
+                __map.reserve(__result->size());
+                for (const auto& __entry : *__result) {
+                  __map.emplace(__entry.first->toStdString(), __entry.second->toStdString());
+                }
+                return __map;
+              }());
+            });
+            __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+              jni::JniException __jniError(__throwable);
+              __promise->reject(std::make_exception_ptr(__jniError));
+            });
+            return __promise;
+          }());
+        });
+        __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+          jni::JniException __jniError(__throwable);
+          __promise->reject(std::make_exception_ptr(__jniError));
+        });
+        return __promise;
+      }();
+    }
+  };
+
+  /**
+   * An implementation of Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string______cxx final: public jni::HybridClass<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string______cxx, JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____> {
+  public:
+    static jni::local_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____::javaobject> fromCpp(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>& func) {
+      return JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string______cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string______cxx` instance holds.
+     */
+    jni::local_ref<JPromise::javaobject> invoke_cxx() {
+      std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>> __result = _func();
+      return [&]() {
+        jni::local_ref<JPromise::javaobject> __localPromise = JPromise::create();
+        jni::global_ref<JPromise::javaobject> __promise = jni::make_global(__localPromise);
+        __result->addOnResolvedListener([=](const std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>& __result) {
+          __promise->cthis()->resolve([&]() {
+            jni::local_ref<JPromise::javaobject> __localPromise = JPromise::create();
+            jni::global_ref<JPromise::javaobject> __promise = jni::make_global(__localPromise);
+            __result->addOnResolvedListener([=](const std::unordered_map<std::string, std::string>& __result) {
+              __promise->cthis()->resolve([&]() -> jni::local_ref<jni::JMap<jni::JString, jni::JString>> {
+                auto __map = jni::JHashMap<jni::JString, jni::JString>::create(__result.size());
+                for (const auto& __entry : __result) {
+                  __map->put(jni::make_jstring(__entry.first), jni::make_jstring(__entry.second));
+                }
+                return __map;
+              }());
+            });
+            __result->addOnRejectedListener([=](const std::exception_ptr& __error) {
+              auto __jniError = jni::getJavaExceptionForCppException(__error);
+              __promise->cthis()->reject(__jniError);
+            });
+            return __localPromise;
+          }());
+        });
+        __result->addOnRejectedListener([=](const std::exception_ptr& __error) {
+          auto __jniError = jni::getJavaExceptionForCppException(__error);
+          __promise->cthis()->reject(__jniError);
+        });
+        return __localPromise;
+      }();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrosse/Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string______cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string______cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string______cxx(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()> _func;
+  };
+
+} // namespace margelo::nitro::nitrosse

package/nitrogen/generated/android/c++/JFunc_void_std__vector_SseEvent_.hpp

@@ -0,0 +1,102 @@
+///
+/// JFunc_void_std__vector_SseEvent_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "SseEvent.hpp"
+#include <vector>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JSseEvent.hpp"
+#include "SseEventType.hpp"
+#include "JSseEventType.hpp"
+#include <string>
+#include <optional>
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
+
+namespace margelo::nitro::nitrosse {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(events: Array<SseEvent>) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_SseEvent_: public jni::JavaClass<JFunc_void_std__vector_SseEvent_> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrosse/Func_void_std__vector_SseEvent_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_SseEvent_` instance holds through JNI.
+     */
+    void invoke(const std::vector<SseEvent>& events) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JSseEvent>> /* events */)>("invoke");
+      method(self(), [&](auto&& __input) {
+        size_t __size = __input.size();
+        jni::local_ref<jni::JArrayClass<JSseEvent>> __array = jni::JArrayClass<JSseEvent>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = __input[__i];
+          auto __elementJni = JSseEvent::fromCpp(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }(events));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_SseEvent_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__vector_SseEvent__cxx final: public jni::HybridClass<JFunc_void_std__vector_SseEvent__cxx, JFunc_void_std__vector_SseEvent_> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_SseEvent_::javaobject> fromCpp(const std::function<void(const std::vector<SseEvent>& /* events */)>& func) {
+      return JFunc_void_std__vector_SseEvent__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_SseEvent__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JSseEvent>> events) {
+      _func([&](auto&& __input) {
+        size_t __size = __input->size();
+        std::vector<SseEvent> __vector;
+        __vector.reserve(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          auto __element = __input->getElement(__i);
+          __vector.push_back(__element->toCpp());
+        }
+        return __vector;
+      }(events));
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<SseEvent>& /* events */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrosse/Func_void_std__vector_SseEvent__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_SseEvent__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_SseEvent__cxx(const std::function<void(const std::vector<SseEvent>& /* events */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<SseEvent>& /* events */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrosse

package/nitrogen/generated/android/c++/JHttpMethod.hpp

@@ -0,0 +1,58 @@
+///
+/// JHttpMethod.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "HttpMethod.hpp"
+
+namespace margelo::nitro::nitrosse {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "HttpMethod" and the the Kotlin enum "HttpMethod".
+   */
+  struct JHttpMethod final: public jni::JavaClass<JHttpMethod> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrosse/HttpMethod;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum HttpMethod.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    HttpMethod toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<HttpMethod>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JHttpMethod> fromCpp(HttpMethod value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case HttpMethod::GET:
+          static const auto fieldGET = clazz->getStaticField<JHttpMethod>("GET");
+          return clazz->getStaticFieldValue(fieldGET);
+        case HttpMethod::POST:
+          static const auto fieldPOST = clazz->getStaticField<JHttpMethod>("POST");
+          return clazz->getStaticFieldValue(fieldPOST);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitrosse