securiti-consent-sdk 1.132.0

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

@@ -0,0 +1,74 @@
+///
+/// JFunc_void_bool.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+
+namespace margelo::nitro::securiticonsentsdk {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(isReady: Boolean) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool: public jni::JavaClass<JFunc_void_bool> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/securiticonsentsdk/Func_void_bool;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool` instance holds through JNI.
+     */
+    void invoke(bool isReady) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* isReady */)>("invoke");
+      method(self(), isReady);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
+  public:
+    static jni::local_ref<JFunc_void_bool::javaobject> fromCpp(const std::function<void(bool /* isReady */)>& func) {
+      return JFunc_void_bool_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean isReady) {
+      _func(static_cast<bool>(isReady));
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* isReady */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/securiticonsentsdk/Func_void_bool_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_cxx(const std::function<void(bool /* isReady */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* isReady */)> _func;
+  };
+
+} // namespace margelo::nitro::securiticonsentsdk

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

@@ -0,0 +1,277 @@
+///
+/// JHybridConsentSDKSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridConsentSDKSpec.hpp"
+
+// Forward declaration of `AppPermission` to properly resolve imports.
+namespace margelo::nitro::securiticonsentsdk { struct AppPermission; }
+// Forward declaration of `Purpose` to properly resolve imports.
+namespace margelo::nitro::securiticonsentsdk { struct Purpose; }
+// Forward declaration of `SDK` to properly resolve imports.
+namespace margelo::nitro::securiticonsentsdk { struct SDK; }
+// Forward declaration of `BannerConfig` to properly resolve imports.
+namespace margelo::nitro::securiticonsentsdk { struct BannerConfig; }
+// Forward declaration of `CustomColors` to properly resolve imports.
+namespace margelo::nitro::securiticonsentsdk { struct CustomColors; }
+// Forward declaration of `CmpSDKOptions` to properly resolve imports.
+namespace margelo::nitro::securiticonsentsdk { struct CmpSDKOptions; }
+// Forward declaration of `SettingsPrompt` to properly resolve imports.
+namespace margelo::nitro::securiticonsentsdk { struct SettingsPrompt; }
+// Forward declaration of `PostConsentsRequest` to properly resolve imports.
+namespace margelo::nitro::securiticonsentsdk { struct PostConsentsRequest; }
+// Forward declaration of `PurposeConsent` to properly resolve imports.
+namespace margelo::nitro::securiticonsentsdk { struct PurposeConsent; }
+// Forward declaration of `PermissionConsent` to properly resolve imports.
+namespace margelo::nitro::securiticonsentsdk { struct PermissionConsent; }
+
+#include <NitroModules/Promise.hpp>
+#include <string>
+#include <NitroModules/JPromise.hpp>
+#include <vector>
+#include "AppPermission.hpp"
+#include "JAppPermission.hpp"
+#include <optional>
+#include "Purpose.hpp"
+#include "JPurpose.hpp"
+#include "SDK.hpp"
+#include "JSDK.hpp"
+#include "BannerConfig.hpp"
+#include "JBannerConfig.hpp"
+#include "CustomColors.hpp"
+#include "JCustomColors.hpp"
+#include <unordered_map>
+#include "CmpSDKOptions.hpp"
+#include "JCmpSDKOptions.hpp"
+#include "SettingsPrompt.hpp"
+#include "JSettingsPrompt.hpp"
+#include <functional>
+#include "JFunc_void_bool.hpp"
+#include "PostConsentsRequest.hpp"
+#include "JPostConsentsRequest.hpp"
+#include "PurposeConsent.hpp"
+#include "JPurposeConsent.hpp"
+#include "PermissionConsent.hpp"
+#include "JPermissionConsent.hpp"
+
+namespace margelo::nitro::securiticonsentsdk {
+
+  jni::local_ref<JHybridConsentSDKSpec::jhybriddata> JHybridConsentSDKSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridConsentSDKSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridConsentSDKSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridConsentSDKSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridConsentSDKSpec::initialize(const CmpSDKOptions& options) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JCmpSDKOptions> /* options */)>("initialize");
+    method(_javaPart, JCmpSDKOptions::fromCpp(options));
+  }
+  bool JHybridConsentSDKSpec::isSdkReady() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("isSdkReady");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridConsentSDKSpec::presentConsentBanner() {
+    static const auto method = javaClassStatic()->getMethod<void()>("presentConsentBanner");
+    method(_javaPart);
+  }
+  void JHybridConsentSDKSpec::presentPreferenceCenter() {
+    static const auto method = javaClassStatic()->getMethod<void()>("presentPreferenceCenter");
+    method(_javaPart);
+  }
+  void JHybridConsentSDKSpec::isReady(const std::function<void(bool /* isReady */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool::javaobject> /* callback */)>("isReady_cxx");
+    method(_javaPart, JFunc_void_bool_cxx::fromCpp(callback));
+  }
+  void JHybridConsentSDKSpec::resetConsents() {
+    static const auto method = javaClassStatic()->getMethod<void()>("resetConsents");
+    method(_javaPart);
+  }
+  std::shared_ptr<Promise<std::string>> JHybridConsentSDKSpec::getConsentByPurposeId(double purposeId) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* purposeId */)>("getConsentByPurposeId");
+    auto __result = method(_javaPart, purposeId);
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::string>> JHybridConsentSDKSpec::getConsentByPermissionId(const std::string& permissionId) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* permissionId */)>("getConsentByPermissionId");
+    auto __result = method(_javaPart, jni::make_jstring(permissionId));
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::vector<AppPermission>>> JHybridConsentSDKSpec::getPermissions() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getPermissions");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::vector<AppPermission>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JAppPermission>>(__boxedResult);
+        __promise->resolve([&]() {
+          size_t __size = __result->size();
+          std::vector<AppPermission> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __result->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::vector<Purpose>>> JHybridConsentSDKSpec::getPurposes() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getPurposes");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::vector<Purpose>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JPurpose>>(__boxedResult);
+        __promise->resolve([&]() {
+          size_t __size = __result->size();
+          std::vector<Purpose> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __result->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::vector<SDK>>> JHybridConsentSDKSpec::getSdksInPurpose(double purposeId) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* purposeId */)>("getSdksInPurpose");
+    auto __result = method(_javaPart, purposeId);
+    return [&]() {
+      auto __promise = Promise<std::vector<SDK>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JSDK>>(__boxedResult);
+        __promise->resolve([&]() {
+          size_t __size = __result->size();
+          std::vector<SDK> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __result->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  bool JHybridConsentSDKSpec::setPurposeConsent(const Purpose& purpose, const std::string& consent) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<JPurpose> /* purpose */, jni::alias_ref<jni::JString> /* consent */)>("setPurposeConsent");
+    auto __result = method(_javaPart, JPurpose::fromCpp(purpose), jni::make_jstring(consent));
+    return static_cast<bool>(__result);
+  }
+  bool JHybridConsentSDKSpec::setPermissionConsent(const AppPermission& permission, const std::string& consent) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<JAppPermission> /* permission */, jni::alias_ref<jni::JString> /* consent */)>("setPermissionConsent");
+    auto __result = method(_javaPart, JAppPermission::fromCpp(permission), jni::make_jstring(consent));
+    return static_cast<bool>(__result);
+  }
+  std::shared_ptr<Promise<std::optional<BannerConfig>>> JHybridConsentSDKSpec::getBannerConfig() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getBannerConfig");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::optional<BannerConfig>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JBannerConfig>(__boxedResult);
+        __promise->resolve(__result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt);
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::optional<CmpSDKOptions> JHybridConsentSDKSpec::options() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JCmpSDKOptions>()>("options");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  std::shared_ptr<Promise<std::optional<SettingsPrompt>>> JHybridConsentSDKSpec::getSettingsPrompt() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getSettingsPrompt");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::optional<SettingsPrompt>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JSettingsPrompt>(__boxedResult);
+        __promise->resolve(__result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt);
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<bool>> JHybridConsentSDKSpec::uploadConsents(const PostConsentsRequest& request) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPostConsentsRequest> /* request */)>("uploadConsents");
+    auto __result = method(_javaPart, JPostConsentsRequest::fromCpp(request));
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+
+} // namespace margelo::nitro::securiticonsentsdk

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

@@ -0,0 +1,78 @@
+///
+/// HybridConsentSDKSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridConsentSDKSpec.hpp"
+
+
+
+
+namespace margelo::nitro::securiticonsentsdk {
+
+  using namespace facebook;
+
+  class JHybridConsentSDKSpec: public jni::HybridClass<JHybridConsentSDKSpec, JHybridObject>,
+                               public virtual HybridConsentSDKSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/securiticonsentsdk/HybridConsentSDKSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridConsentSDKSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridConsentSDKSpec::TAG),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridConsentSDKSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+
+  public:
+    inline const jni::global_ref<JHybridConsentSDKSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void initialize(const CmpSDKOptions& options) override;
+    bool isSdkReady() override;
+    void presentConsentBanner() override;
+    void presentPreferenceCenter() override;
+    void isReady(const std::function<void(bool /* isReady */)>& callback) override;
+    void resetConsents() override;
+    std::shared_ptr<Promise<std::string>> getConsentByPurposeId(double purposeId) override;
+    std::shared_ptr<Promise<std::string>> getConsentByPermissionId(const std::string& permissionId) override;
+    std::shared_ptr<Promise<std::vector<AppPermission>>> getPermissions() override;
+    std::shared_ptr<Promise<std::vector<Purpose>>> getPurposes() override;
+    std::shared_ptr<Promise<std::vector<SDK>>> getSdksInPurpose(double purposeId) override;
+    bool setPurposeConsent(const Purpose& purpose, const std::string& consent) override;
+    bool setPermissionConsent(const AppPermission& permission, const std::string& consent) override;
+    std::shared_ptr<Promise<std::optional<BannerConfig>>> getBannerConfig() override;
+    std::optional<CmpSDKOptions> options() override;
+    std::shared_ptr<Promise<std::optional<SettingsPrompt>>> getSettingsPrompt() override;
+    std::shared_ptr<Promise<bool>> uploadConsents(const PostConsentsRequest& request) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridConsentSDKSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::securiticonsentsdk

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

@@ -0,0 +1,61 @@
+///
+/// JPermissionConsent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PermissionConsent.hpp"
+
+#include <string>
+
+namespace margelo::nitro::securiticonsentsdk {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PermissionConsent" and the the Kotlin data class "PermissionConsent".
+   */
+  struct JPermissionConsent final: public jni::JavaClass<JPermissionConsent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/securiticonsentsdk/PermissionConsent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PermissionConsent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PermissionConsent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPermission = clazz->getField<jni::JString>("permission");
+      jni::local_ref<jni::JString> permission = this->getFieldValue(fieldPermission);
+      static const auto fieldConsentStatus = clazz->getField<jni::JString>("consentStatus");
+      jni::local_ref<jni::JString> consentStatus = this->getFieldValue(fieldConsentStatus);
+      static const auto fieldTimestamp = clazz->getField<double>("timestamp");
+      double timestamp = this->getFieldValue(fieldTimestamp);
+      return PermissionConsent(
+        permission->toStdString(),
+        consentStatus->toStdString(),
+        timestamp
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JPermissionConsent::javaobject> fromCpp(const PermissionConsent& value) {
+      return newInstance(
+        jni::make_jstring(value.permission),
+        jni::make_jstring(value.consentStatus),
+        value.timestamp
+      );
+    }
+  };
+
+} // namespace margelo::nitro::securiticonsentsdk

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

@@ -0,0 +1,137 @@
+///
+/// JPostConsentsRequest.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PostConsentsRequest.hpp"
+
+#include "JPermissionConsent.hpp"
+#include "JPurposeConsent.hpp"
+#include "PermissionConsent.hpp"
+#include "PurposeConsent.hpp"
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::securiticonsentsdk {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PostConsentsRequest" and the the Kotlin data class "PostConsentsRequest".
+   */
+  struct JPostConsentsRequest final: public jni::JavaClass<JPostConsentsRequest> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/securiticonsentsdk/PostConsentsRequest;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PostConsentsRequest by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PostConsentsRequest toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldUuid = clazz->getField<jni::JString>("uuid");
+      jni::local_ref<jni::JString> uuid = this->getFieldValue(fieldUuid);
+      static const auto fieldAppUUID = clazz->getField<jni::JString>("appUUID");
+      jni::local_ref<jni::JString> appUUID = this->getFieldValue(fieldAppUUID);
+      static const auto fieldDevice = clazz->getField<jni::JString>("device");
+      jni::local_ref<jni::JString> device = this->getFieldValue(fieldDevice);
+      static const auto fieldImplicitConsent = clazz->getField<jboolean>("implicitConsent");
+      jboolean implicitConsent = this->getFieldValue(fieldImplicitConsent);
+      static const auto fieldVersion = clazz->getField<double>("version");
+      double version = this->getFieldValue(fieldVersion);
+      static const auto fieldPurposeConsents = clazz->getField<jni::JArrayClass<JPurposeConsent>>("purposeConsents");
+      jni::local_ref<jni::JArrayClass<JPurposeConsent>> purposeConsents = this->getFieldValue(fieldPurposeConsents);
+      static const auto fieldPermissions = clazz->getField<jni::JArrayClass<JPermissionConsent>>("permissions");
+      jni::local_ref<jni::JArrayClass<JPermissionConsent>> permissions = this->getFieldValue(fieldPermissions);
+      static const auto fieldIsTestMode = clazz->getField<jboolean>("isTestMode");
+      jboolean isTestMode = this->getFieldValue(fieldIsTestMode);
+      static const auto fieldAdId = clazz->getField<jni::JString>("adId");
+      jni::local_ref<jni::JString> adId = this->getFieldValue(fieldAdId);
+      static const auto fieldBannerInfo = clazz->getField<jni::JString>("bannerInfo");
+      jni::local_ref<jni::JString> bannerInfo = this->getFieldValue(fieldBannerInfo);
+      static const auto fieldSdkVersion = clazz->getField<jni::JString>("sdkVersion");
+      jni::local_ref<jni::JString> sdkVersion = this->getFieldValue(fieldSdkVersion);
+      static const auto fieldPlatform = clazz->getField<jni::JString>("platform");
+      jni::local_ref<jni::JString> platform = this->getFieldValue(fieldPlatform);
+      return PostConsentsRequest(
+        uuid->toStdString(),
+        appUUID->toStdString(),
+        device->toStdString(),
+        static_cast<bool>(implicitConsent),
+        version,
+        [&]() {
+          size_t __size = purposeConsents->size();
+          std::vector<PurposeConsent> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = purposeConsents->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(),
+        [&]() {
+          size_t __size = permissions->size();
+          std::vector<PermissionConsent> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = permissions->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(),
+        static_cast<bool>(isTestMode),
+        adId->toStdString(),
+        bannerInfo->toStdString(),
+        sdkVersion != nullptr ? std::make_optional(sdkVersion->toStdString()) : std::nullopt,
+        platform != nullptr ? std::make_optional(platform->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<JPostConsentsRequest::javaobject> fromCpp(const PostConsentsRequest& value) {
+      return newInstance(
+        jni::make_jstring(value.uuid),
+        jni::make_jstring(value.appUUID),
+        jni::make_jstring(value.device),
+        value.implicitConsent,
+        value.version,
+        [&]() {
+          size_t __size = value.purposeConsents.size();
+          jni::local_ref<jni::JArrayClass<JPurposeConsent>> __array = jni::JArrayClass<JPurposeConsent>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.purposeConsents[__i];
+            __array->setElement(__i, *JPurposeConsent::fromCpp(__element));
+          }
+          return __array;
+        }(),
+        [&]() {
+          size_t __size = value.permissions.size();
+          jni::local_ref<jni::JArrayClass<JPermissionConsent>> __array = jni::JArrayClass<JPermissionConsent>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.permissions[__i];
+            __array->setElement(__i, *JPermissionConsent::fromCpp(__element));
+          }
+          return __array;
+        }(),
+        value.isTestMode,
+        jni::make_jstring(value.adId),
+        jni::make_jstring(value.bannerInfo),
+        value.sdkVersion.has_value() ? jni::make_jstring(value.sdkVersion.value()) : nullptr,
+        value.platform.has_value() ? jni::make_jstring(value.platform.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::securiticonsentsdk