react-native-nitro-country-picker 0.1.0

package/ios/NitroCountryPicker.swift

@@ -0,0 +1,94 @@
+import CountryPickerAKS
+import NitroModules
+import React
+import UIKit
+
+class NitroCountryPicker: HybridNitroCountryPickerSpec {
+  private var lastPickedCountry: IPickedCountry? = nil
+  private var pendingPickPromise: Promise<Variant_NullType_IPickedCountry>? = nil
+
+  private func makeError(_ message: String) -> Error {
+    return NSError(
+      domain: "NitroCountryPicker", code: 1, userInfo: [NSLocalizedDescriptionKey: message])
+  }
+
+  @MainActor
+  private func resolvePendingPick(country: IPickedCountry?) {
+    guard let promise = pendingPickPromise else {
+      return
+    }
+    pendingPickPromise = nil
+
+    let result: Variant_NullType_IPickedCountry = country.map { .second($0) } ?? .first(.null)
+    promise.resolve(withResult: result)
+  }
+
+  @MainActor
+  private func rejectPendingPick(error: Error) {
+    guard let promise = pendingPickPromise else {
+      return
+    }
+    pendingPickPromise = nil
+
+    promise.reject(withError: error)
+  }
+
+  @MainActor
+  private func openPicker(
+    options: PickCountryOptions?,
+    promise: Promise<Variant_NullType_IPickedCountry>
+  ) {
+    if pendingPickPromise != nil {
+      promise.reject(withError: makeError("Country picker is already open."))
+      return
+    }
+    pendingPickPromise = promise
+
+    guard let presenter = RCTPresentedViewController() else {
+      rejectPendingPick(
+        error: makeError("No active UIViewController available to present country picker."))
+      return
+    }
+
+    // CountryPickerAKS does not expose a dedicated header-title config yet.
+    _ = options?.headerTitle
+
+    CountryPicker.show(from: presenter) { [weak self] result in
+      guard let self else { return }
+      switch result {
+      case .success(let selected):
+        let picked = IPickedCountry(
+          name: selected.name,
+          dialCode: selected.dial_code,
+          code: selected.code
+        )
+        self.lastPickedCountry = picked
+        self.resolvePendingPick(country: picked)
+      case .failure(let error):
+        switch error {
+        case .NotSelected:
+          self.resolvePendingPick(country: nil)
+        default:
+          self.rejectPendingPick(error: error)
+        }
+      }
+    }
+  }
+
+  func pickCountry(options: PickCountryOptions?) throws -> Promise<Variant_NullType_IPickedCountry>
+  {
+    let promise = Promise<Variant_NullType_IPickedCountry>()
+    Task { @MainActor [weak self] in
+      guard let self else { return }
+      self.openPicker(options: options, promise: promise)
+    }
+    return promise
+  }
+
+  func getLastPickedCountry() throws -> Variant_NullType_IPickedCountry {
+    if let picked = lastPickedCountry {
+      return .second(picked)
+    }
+    return .first(.null)
+  }
+}

package/lib/module/NitroCountryPicker.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=NitroCountryPicker.nitro.js.map

package/lib/module/NitroCountryPicker.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["NitroCountryPicker.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+const NitroCountryPickerHybridObject = NitroModules.createHybridObject('NitroCountryPicker');
+export function pickCountry(options) {
+  return NitroCountryPickerHybridObject.pickCountry(options);
+}
+export function getLastPickedCountry() {
+  return NitroCountryPickerHybridObject.getLastPickedCountry();
+}
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","NitroCountryPickerHybridObject","createHybridObject","pickCountry","options","getLastPickedCountry"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAOzD,MAAMC,8BAA8B,GAClCD,YAAY,CAACE,kBAAkB,CAAqB,oBAAoB,CAAC;AAE3E,OAAO,SAASC,WAAWA,CACzBC,OAA4B,EACI;EAChC,OAAOH,8BAA8B,CAACE,WAAW,CAACC,OAAO,CAAC;AAC5D;AAEA,OAAO,SAASC,oBAAoBA,CAAA,EAA0B;EAC5D,OAAOJ,8BAA8B,CAACI,oBAAoB,CAAC,CAAC;AAC9D","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/NitroCountryPicker.nitro.d.ts

@@ -0,0 +1,17 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export interface IPickedCountry {
+    name: string;
+    dialCode: string;
+    code: string;
+}
+export interface PickCountryOptions {
+    headerTitle?: string;
+}
+export interface NitroCountryPicker extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    pickCountry(options?: PickCountryOptions): Promise<IPickedCountry | null>;
+    getLastPickedCountry(): IPickedCountry | null;
+}
+//# sourceMappingURL=NitroCountryPicker.nitro.d.ts.map

package/lib/typescript/src/NitroCountryPicker.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NitroCountryPicker.nitro.d.ts","sourceRoot":"","sources":["../../../src/NitroCountryPicker.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAmB,SAAQ,YAAY,CAAC;IACvD,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,QAAQ,CAAC;CACnB,CAAC;IACA,WAAW,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAE1E,oBAAoB,IAAI,cAAc,GAAG,IAAI,CAAC;CAC/C"}

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

@@ -0,0 +1,4 @@
+import type { IPickedCountry, PickCountryOptions } from './NitroCountryPicker.nitro';
+export declare function pickCountry(options?: PickCountryOptions): Promise<IPickedCountry | null>;
+export declare function getLastPickedCountry(): IPickedCountry | null;
+//# 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.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EAEd,kBAAkB,EACnB,MAAM,4BAA4B,CAAC;AAKpC,wBAAgB,WAAW,CACzB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAEhC;AAED,wBAAgB,oBAAoB,IAAI,cAAc,GAAG,IAAI,CAE5D"}

package/nitro.json

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

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

@@ -0,0 +1,83 @@
+///
+/// JHybridNitroCountryPickerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroCountryPickerSpec.hpp"
+
+// Forward declaration of `IPickedCountry` to properly resolve imports.
+namespace margelo::nitro::nitrocountrypicker { struct IPickedCountry; }
+// Forward declaration of `PickCountryOptions` to properly resolve imports.
+namespace margelo::nitro::nitrocountrypicker { struct PickCountryOptions; }
+
+#include <NitroModules/Null.hpp>
+#include "IPickedCountry.hpp"
+#include <variant>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JVariant_NullType_IPickedCountry.hpp"
+#include <NitroModules/JNull.hpp>
+#include "JIPickedCountry.hpp"
+#include <string>
+#include "PickCountryOptions.hpp"
+#include <optional>
+#include "JPickCountryOptions.hpp"
+
+namespace margelo::nitro::nitrocountrypicker {
+
+  std::shared_ptr<JHybridNitroCountryPickerSpec> JHybridNitroCountryPickerSpec::JavaPart::getJHybridNitroCountryPickerSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridNitroCountryPickerSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridNitroCountryPickerSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridNitroCountryPickerSpec::CxxPart::jhybriddata> JHybridNitroCountryPickerSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridNitroCountryPickerSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridNitroCountryPickerSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridNitroCountryPickerSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridNitroCountryPickerSpec>(castJavaPart);
+  }
+
+  void JHybridNitroCountryPickerSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroCountryPickerSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<std::variant<nitro::NullType, IPickedCountry>>> JHybridNitroCountryPickerSpec::pickCountry(const std::optional<PickCountryOptions>& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPickCountryOptions> /* options */)>("pickCountry");
+    auto __result = method(_javaPart, options.has_value() ? JPickCountryOptions::fromCpp(options.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<std::variant<nitro::NullType, IPickedCountry>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JVariant_NullType_IPickedCountry>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::variant<nitro::NullType, IPickedCountry> JHybridNitroCountryPickerSpec::getLastPickedCountry() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_NullType_IPickedCountry>()>("getLastPickedCountry");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+
+} // namespace margelo::nitro::nitrocountrypicker

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

@@ -0,0 +1,64 @@
+///
+/// HybridNitroCountryPickerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridNitroCountryPickerSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitrocountrypicker {
+
+  using namespace facebook;
+
+  class JHybridNitroCountryPickerSpec: public virtual HybridNitroCountryPickerSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocountrypicker/HybridNitroCountryPickerSpec;";
+      std::shared_ptr<JHybridNitroCountryPickerSpec> getJHybridNitroCountryPickerSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocountrypicker/HybridNitroCountryPickerSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridNitroCountryPickerSpec(const jni::local_ref<JHybridNitroCountryPickerSpec::JavaPart>& javaPart):
+      HybridObject(HybridNitroCountryPickerSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridNitroCountryPickerSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridNitroCountryPickerSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<std::variant<nitro::NullType, IPickedCountry>>> pickCountry(const std::optional<PickCountryOptions>& options) override;
+    std::variant<nitro::NullType, IPickedCountry> getLastPickedCountry() override;
+
+  private:
+    jni::global_ref<JHybridNitroCountryPickerSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitrocountrypicker

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

@@ -0,0 +1,65 @@
+///
+/// JIPickedCountry.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 "IPickedCountry.hpp"
+
+#include <string>
+
+namespace margelo::nitro::nitrocountrypicker {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "IPickedCountry" and the the Kotlin data class "IPickedCountry".
+   */
+  struct JIPickedCountry final: public jni::JavaClass<JIPickedCountry> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocountrypicker/IPickedCountry;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct IPickedCountry by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    IPickedCountry toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      static const auto fieldDialCode = clazz->getField<jni::JString>("dialCode");
+      jni::local_ref<jni::JString> dialCode = this->getFieldValue(fieldDialCode);
+      static const auto fieldCode = clazz->getField<jni::JString>("code");
+      jni::local_ref<jni::JString> code = this->getFieldValue(fieldCode);
+      return IPickedCountry(
+        name->toStdString(),
+        dialCode->toStdString(),
+        code->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JIPickedCountry::javaobject> fromCpp(const IPickedCountry& value) {
+      using JSignature = JIPickedCountry(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.name),
+        jni::make_jstring(value.dialCode),
+        jni::make_jstring(value.code)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrocountrypicker

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

@@ -0,0 +1,58 @@
+///
+/// JPickCountryOptions.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 "PickCountryOptions.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::nitrocountrypicker {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PickCountryOptions" and the the Kotlin data class "PickCountryOptions".
+   */
+  struct JPickCountryOptions final: public jni::JavaClass<JPickCountryOptions> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocountrypicker/PickCountryOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PickCountryOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PickCountryOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldHeaderTitle = clazz->getField<jni::JString>("headerTitle");
+      jni::local_ref<jni::JString> headerTitle = this->getFieldValue(fieldHeaderTitle);
+      return PickCountryOptions(
+        headerTitle != nullptr ? std::make_optional(headerTitle->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<JPickCountryOptions::javaobject> fromCpp(const PickCountryOptions& value) {
+      using JSignature = JPickCountryOptions(jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.headerTitle.has_value() ? jni::make_jstring(value.headerTitle.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrocountrypicker

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

@@ -0,0 +1,26 @@
+///
+/// JVariant_NullType_IPickedCountry.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JVariant_NullType_IPickedCountry.hpp"
+
+namespace margelo::nitro::nitrocountrypicker {
+  /**
+   * Converts JVariant_NullType_IPickedCountry to std::variant<nitro::NullType, IPickedCountry>
+   */
+  std::variant<nitro::NullType, IPickedCountry> JVariant_NullType_IPickedCountry::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_IPickedCountry_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_IPickedCountry_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_IPickedCountry_impl::Second::javaClassStatic())) {
+      // It's a `IPickedCountry`
+      auto jniValue = static_cast<const JVariant_NullType_IPickedCountry_impl::Second*>(this)->getValue();
+      return jniValue->toCpp();
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::nitrocountrypicker

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

@@ -0,0 +1,72 @@
+///
+/// JVariant_NullType_IPickedCountry.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 <variant>
+
+#include <NitroModules/Null.hpp>
+#include "IPickedCountry.hpp"
+#include <variant>
+#include <NitroModules/JNull.hpp>
+#include "JIPickedCountry.hpp"
+#include <string>
+
+namespace margelo::nitro::nitrocountrypicker {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_IPickedCountry".
+   */
+  class JVariant_NullType_IPickedCountry: public jni::JavaClass<JVariant_NullType_IPickedCountry> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocountrypicker/Variant_NullType_IPickedCountry;";
+
+    static jni::local_ref<JVariant_NullType_IPickedCountry> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_IPickedCountry(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_IPickedCountry> create_1(jni::alias_ref<JIPickedCountry> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_IPickedCountry(jni::alias_ref<JIPickedCountry>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_IPickedCountry> fromCpp(const std::variant<nitro::NullType, IPickedCountry>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(JIPickedCountry::fromCpp(std::get<1>(variant)));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, IPickedCountry> toCpp() const;
+  };
+
+  namespace JVariant_NullType_IPickedCountry_impl {
+    class First final: public jni::JavaClass<First, JVariant_NullType_IPickedCountry> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocountrypicker/Variant_NullType_IPickedCountry$First;";
+    
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second final: public jni::JavaClass<Second, JVariant_NullType_IPickedCountry> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocountrypicker/Variant_NullType_IPickedCountry$Second;";
+    
+      [[nodiscard]] jni::local_ref<JIPickedCountry> getValue() const {
+        static const auto field = javaClassStatic()->getField<JIPickedCountry>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_IPickedCountry_impl
+} // namespace margelo::nitro::nitrocountrypicker

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrocountrypicker/HybridNitroCountryPickerSpec.kt

@@ -0,0 +1,60 @@
+///
+/// HybridNitroCountryPickerSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitrocountrypicker
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.NullType
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the NitroCountryPicker HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of NitroCountryPicker.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridNitroCountryPickerSpec: HybridObject() {
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun pickCountry(options: PickCountryOptions?): Promise<Variant_NullType_IPickedCountry>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getLastPickedCountry(): Variant_NullType_IPickedCountry
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject NitroCountryPicker]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridNitroCountryPickerSpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridNitroCountryPickerSpec::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
+
+  companion object {
+    protected const val TAG = "HybridNitroCountryPickerSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrocountrypicker/IPickedCountry.kt

@@ -0,0 +1,44 @@
+///
+/// IPickedCountry.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitrocountrypicker
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "IPickedCountry".
+ */
+@DoNotStrip
+@Keep
+data class IPickedCountry(
+  @DoNotStrip
+  @Keep
+  val name: String,
+  @DoNotStrip
+  @Keep
+  val dialCode: String,
+  @DoNotStrip
+  @Keep
+  val code: String
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(name: String, dialCode: String, code: String): IPickedCountry {
+      return IPickedCountry(name, dialCode, code)
+    }
+  }
+}