react-native-pangleads 0.1.0

package/nitrogen/generated/android/c++/JHybridPangleRewardedAdSpec.cpp

@@ -0,0 +1,89 @@
+///
+/// JHybridPangleRewardedAdSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridPangleRewardedAdSpec.hpp"
+
+// Forward declaration of `PangleAdVerificationOptions` to properly resolve imports.
+namespace margelo::nitro::pangleads { struct PangleAdVerificationOptions; }
+// Forward declaration of `PangleAdEventType` to properly resolve imports.
+namespace margelo::nitro::pangleads { enum class PangleAdEventType; }
+// Forward declaration of `PangleAdEventPayload` to properly resolve imports.
+namespace margelo::nitro::pangleads { struct PangleAdEventPayload; }
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "PangleAdVerificationOptions.hpp"
+#include <optional>
+#include "JPangleAdVerificationOptions.hpp"
+#include <string>
+#include "PangleAdEventType.hpp"
+#include "JPangleAdEventType.hpp"
+#include "PangleAdEventPayload.hpp"
+#include <functional>
+#include "JFunc_void_std__optional_PangleAdEventPayload_.hpp"
+#include "JPangleAdEventPayload.hpp"
+
+namespace margelo::nitro::pangleads {
+
+  jni::local_ref<JHybridPangleRewardedAdSpec::jhybriddata> JHybridPangleRewardedAdSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridPangleRewardedAdSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridPangleRewardedAdSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridPangleRewardedAdSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridPangleRewardedAdSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridPangleRewardedAdSpec::load(const std::optional<PangleAdVerificationOptions>& verification) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPangleAdVerificationOptions> /* verification */)>("load");
+    method(_javaPart, verification.has_value() ? JPangleAdVerificationOptions::fromCpp(verification.value()) : nullptr);
+  }
+  std::shared_ptr<Promise<void>> JHybridPangleRewardedAdSpec::show() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("show");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  double JHybridPangleRewardedAdSpec::addAdEventListener(PangleAdEventType eventType, const std::function<void(const std::optional<PangleAdEventPayload>& /* payload */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<JPangleAdEventType> /* eventType */, jni::alias_ref<JFunc_void_std__optional_PangleAdEventPayload_::javaobject> /* listener */)>("addAdEventListener_cxx");
+    auto __result = method(_javaPart, JPangleAdEventType::fromCpp(eventType), JFunc_void_std__optional_PangleAdEventPayload__cxx::fromCpp(listener));
+    return __result;
+  }
+  void JHybridPangleRewardedAdSpec::removeAdEventListener(double subscriptionId) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* subscriptionId */)>("removeAdEventListener");
+    method(_javaPart, subscriptionId);
+  }
+  void JHybridPangleRewardedAdSpec::removeAllListeners() {
+    static const auto method = javaClassStatic()->getMethod<void()>("removeAllListeners");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::pangleads

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

@@ -0,0 +1,68 @@
+///
+/// HybridPangleRewardedAdSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridPangleRewardedAdSpec.hpp"
+
+
+
+
+namespace margelo::nitro::pangleads {
+
+  using namespace facebook;
+
+  class JHybridPangleRewardedAdSpec: public jni::HybridClass<JHybridPangleRewardedAdSpec, JHybridObject>,
+                                     public virtual HybridPangleRewardedAdSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pangleads/HybridPangleRewardedAdSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridPangleRewardedAdSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridPangleRewardedAdSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridPangleRewardedAdSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+
+  public:
+    inline const jni::global_ref<JHybridPangleRewardedAdSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void load(const std::optional<PangleAdVerificationOptions>& verification) override;
+    std::shared_ptr<Promise<void>> show() override;
+    double addAdEventListener(PangleAdEventType eventType, const std::function<void(const std::optional<PangleAdEventPayload>& /* payload */)>& listener) override;
+    void removeAdEventListener(double subscriptionId) override;
+    void removeAllListeners() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridPangleRewardedAdSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::pangleads

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

@@ -0,0 +1,58 @@
+///
+/// JPangleAdEventPayload.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PangleAdEventPayload.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::pangleads {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PangleAdEventPayload" and the the Kotlin data class "PangleAdEventPayload".
+   */
+  struct JPangleAdEventPayload final: public jni::JavaClass<JPangleAdEventPayload> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pangleads/PangleAdEventPayload;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PangleAdEventPayload by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PangleAdEventPayload toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldErrorCode = clazz->getField<jni::JDouble>("errorCode");
+      jni::local_ref<jni::JDouble> errorCode = this->getFieldValue(fieldErrorCode);
+      static const auto fieldErrorMessage = clazz->getField<jni::JString>("errorMessage");
+      jni::local_ref<jni::JString> errorMessage = this->getFieldValue(fieldErrorMessage);
+      return PangleAdEventPayload(
+        errorCode != nullptr ? std::make_optional(errorCode->value()) : std::nullopt,
+        errorMessage != nullptr ? std::make_optional(errorMessage->toStdString()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JPangleAdEventPayload::javaobject> fromCpp(const PangleAdEventPayload& value) {
+      return newInstance(
+        value.errorCode.has_value() ? jni::JDouble::valueOf(value.errorCode.value()) : nullptr,
+        value.errorMessage.has_value() ? jni::make_jstring(value.errorMessage.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::pangleads

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

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

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

@@ -0,0 +1,58 @@
+///
+/// JPangleAdVerificationOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PangleAdVerificationOptions.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::pangleads {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PangleAdVerificationOptions" and the the Kotlin data class "PangleAdVerificationOptions".
+   */
+  struct JPangleAdVerificationOptions final: public jni::JavaClass<JPangleAdVerificationOptions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/pangleads/PangleAdVerificationOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PangleAdVerificationOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PangleAdVerificationOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldUserId = clazz->getField<jni::JString>("userId");
+      jni::local_ref<jni::JString> userId = this->getFieldValue(fieldUserId);
+      static const auto fieldCustomData = clazz->getField<jni::JString>("customData");
+      jni::local_ref<jni::JString> customData = this->getFieldValue(fieldCustomData);
+      return PangleAdVerificationOptions(
+        userId != nullptr ? std::make_optional(userId->toStdString()) : std::nullopt,
+        customData != nullptr ? std::make_optional(customData->toStdString()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JPangleAdVerificationOptions::javaobject> fromCpp(const PangleAdVerificationOptions& value) {
+      return newInstance(
+        value.userId.has_value() ? jni::make_jstring(value.userId.value()) : nullptr,
+        value.customData.has_value() ? jni::make_jstring(value.customData.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::pangleads

package/nitrogen/generated/android/kotlin/com/margelo/nitro/pangleads/Func_void_std__optional_PangleAdEventPayload_.kt

@@ -0,0 +1,81 @@
+///
+/// Func_void_std__optional_PangleAdEventPayload_.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.pangleads
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.*
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(payload: optional) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_std__optional_PangleAdEventPayload_: (PangleAdEventPayload?) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(payload: PangleAdEventPayload?): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(payload: optional) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_std__optional_PangleAdEventPayload__cxx: Func_void_std__optional_PangleAdEventPayload_ {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(payload: PangleAdEventPayload?): Unit
+    = invoke_cxx(payload)
+
+  @FastNative
+  private external fun invoke_cxx(payload: PangleAdEventPayload?): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(payload: optional) => void`.
+ * This is implemented in Java/Kotlin, via a `(PangleAdEventPayload?) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_std__optional_PangleAdEventPayload__java(private val function: (PangleAdEventPayload?) -> Unit): Func_void_std__optional_PangleAdEventPayload_ {
+  @DoNotStrip
+  @Keep
+  override fun invoke(payload: PangleAdEventPayload?): Unit {
+    return this.function(payload)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/pangleads/HybridPangleAdsSpec.kt

@@ -0,0 +1,72 @@
+///
+/// HybridPangleAdsSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.pangleads
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.*
+
+/**
+ * A Kotlin class representing the PangleAds HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of PangleAds.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridPangleAdsSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun initialize(appId: String): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setGDPRConsent(optIn: Boolean): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setCCPAConsent(optIn: Boolean): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setCOPPA(isUserCoppa: Boolean): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun createInterstitialAd(placementId: String): HybridPangleInterstitialAdSpec
+  
+  @DoNotStrip
+  @Keep
+  abstract fun createRewardedAd(placementId: String): HybridPangleRewardedAdSpec
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    private const val TAG = "HybridPangleAdsSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/pangleads/HybridPangleInterstitialAdSpec.kt

@@ -0,0 +1,73 @@
+///
+/// HybridPangleInterstitialAdSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.pangleads
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.*
+
+/**
+ * A Kotlin class representing the PangleInterstitialAd HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of PangleInterstitialAd.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridPangleInterstitialAdSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun load(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun show(): Promise<Unit>
+  
+  abstract fun addAdEventListener(eventType: PangleAdEventType, listener: (payload: PangleAdEventPayload?) -> Unit): Double
+  
+  @DoNotStrip
+  @Keep
+  private fun addAdEventListener_cxx(eventType: PangleAdEventType, listener: Func_void_std__optional_PangleAdEventPayload_): Double {
+    val __result = addAdEventListener(eventType, listener)
+    return __result
+  }
+  
+  @DoNotStrip
+  @Keep
+  abstract fun removeAdEventListener(subscriptionId: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun removeAllListeners(): Unit
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    private const val TAG = "HybridPangleInterstitialAdSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/pangleads/HybridPangleRewardedAdSpec.kt

@@ -0,0 +1,73 @@
+///
+/// HybridPangleRewardedAdSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.pangleads
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.*
+
+/**
+ * A Kotlin class representing the PangleRewardedAd HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of PangleRewardedAd.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridPangleRewardedAdSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun load(verification: PangleAdVerificationOptions?): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun show(): Promise<Unit>
+  
+  abstract fun addAdEventListener(eventType: PangleAdEventType, listener: (payload: PangleAdEventPayload?) -> Unit): Double
+  
+  @DoNotStrip
+  @Keep
+  private fun addAdEventListener_cxx(eventType: PangleAdEventType, listener: Func_void_std__optional_PangleAdEventPayload_): Double {
+    val __result = addAdEventListener(eventType, listener)
+    return __result
+  }
+  
+  @DoNotStrip
+  @Keep
+  abstract fun removeAdEventListener(subscriptionId: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun removeAllListeners(): Unit
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    private const val TAG = "HybridPangleRewardedAdSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/pangleads/NitroPangleAdsOnLoad.kt

@@ -0,0 +1,35 @@
+///
+/// NitroPangleAdsOnLoad.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.pangleads
+
+import android.util.Log
+
+internal class NitroPangleAdsOnLoad {
+  companion object {
+    private const val TAG = "NitroPangleAdsOnLoad"
+    private var didLoad = false
+    /**
+     * Initializes the native part of "NitroPangleAds".
+     * This method is idempotent and can be called more than once.
+     */
+    @JvmStatic
+    fun initializeNative() {
+      if (didLoad) return
+      try {
+        Log.i(TAG, "Loading NitroPangleAds C++ library...")
+        System.loadLibrary("NitroPangleAds")
+        Log.i(TAG, "Successfully loaded NitroPangleAds C++ library!")
+        didLoad = true
+      } catch (e: Error) {
+        Log.e(TAG, "Failed to load NitroPangleAds C++ library! Is it properly installed and linked? " +
+                    "Is the name correct? (see `CMakeLists.txt`, at `add_library(...)`)", e)
+        throw e
+      }
+    }
+  }
+}