@gmisoftware/react-native-pay 0.0.4

package/nitrogen/generated/ios/NitroPay-Swift-Cxx-Bridge.hpp

@@ -0,0 +1,415 @@
+///
+/// NitroPay-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `CNContactType` to properly resolve imports.
+namespace margelo::nitro::pay { enum class CNContactType; }
+// Forward declaration of `CNContact` to properly resolve imports.
+namespace margelo::nitro::pay { struct CNContact; }
+// Forward declaration of `CNLabeledEmailAddress` to properly resolve imports.
+namespace margelo::nitro::pay { struct CNLabeledEmailAddress; }
+// Forward declaration of `CNLabeledPhoneNumber` to properly resolve imports.
+namespace margelo::nitro::pay { struct CNLabeledPhoneNumber; }
+// Forward declaration of `CNLabeledPostalAddress` to properly resolve imports.
+namespace margelo::nitro::pay { struct CNLabeledPostalAddress; }
+// Forward declaration of `CNPhoneNumber` to properly resolve imports.
+namespace margelo::nitro::pay { struct CNPhoneNumber; }
+// Forward declaration of `CNPostalAddress` to properly resolve imports.
+namespace margelo::nitro::pay { struct CNPostalAddress; }
+// Forward declaration of `GooglePayEnvironment` to properly resolve imports.
+namespace margelo::nitro::pay { enum class GooglePayEnvironment; }
+// Forward declaration of `HybridApplePayButtonSpec` to properly resolve imports.
+namespace margelo::nitro::pay { class HybridApplePayButtonSpec; }
+// Forward declaration of `HybridPaymentHandlerSpec` to properly resolve imports.
+namespace margelo::nitro::pay { class HybridPaymentHandlerSpec; }
+// Forward declaration of `PKSecureElementPass` to properly resolve imports.
+namespace margelo::nitro::pay { struct PKSecureElementPass; }
+// Forward declaration of `PassActivationState` to properly resolve imports.
+namespace margelo::nitro::pay { enum class PassActivationState; }
+// Forward declaration of `PayServiceStatus` to properly resolve imports.
+namespace margelo::nitro::pay { struct PayServiceStatus; }
+// Forward declaration of `PaymentItemType` to properly resolve imports.
+namespace margelo::nitro::pay { enum class PaymentItemType; }
+// Forward declaration of `PaymentItem` to properly resolve imports.
+namespace margelo::nitro::pay { struct PaymentItem; }
+// Forward declaration of `PaymentMethodType` to properly resolve imports.
+namespace margelo::nitro::pay { enum class PaymentMethodType; }
+// Forward declaration of `PaymentMethod` to properly resolve imports.
+namespace margelo::nitro::pay { struct PaymentMethod; }
+// Forward declaration of `PaymentNetwork` to properly resolve imports.
+namespace margelo::nitro::pay { enum class PaymentNetwork; }
+// Forward declaration of `PaymentResult` to properly resolve imports.
+namespace margelo::nitro::pay { struct PaymentResult; }
+// Forward declaration of `PaymentToken` to properly resolve imports.
+namespace margelo::nitro::pay { struct PaymentToken; }
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridApplePayButtonSpec_cxx` to properly resolve imports.
+namespace NitroPay { class HybridApplePayButtonSpec_cxx; }
+// Forward declaration of `HybridPaymentHandlerSpec_cxx` to properly resolve imports.
+namespace NitroPay { class HybridPaymentHandlerSpec_cxx; }
+
+// Include C++ defined types
+#include "CNContact.hpp"
+#include "CNContactType.hpp"
+#include "CNLabeledEmailAddress.hpp"
+#include "CNLabeledPhoneNumber.hpp"
+#include "CNLabeledPostalAddress.hpp"
+#include "CNPhoneNumber.hpp"
+#include "CNPostalAddress.hpp"
+#include "GooglePayEnvironment.hpp"
+#include "HybridApplePayButtonSpec.hpp"
+#include "HybridPaymentHandlerSpec.hpp"
+#include "PKSecureElementPass.hpp"
+#include "PassActivationState.hpp"
+#include "PayServiceStatus.hpp"
+#include "PaymentItem.hpp"
+#include "PaymentItemType.hpp"
+#include "PaymentMethod.hpp"
+#include "PaymentMethodType.hpp"
+#include "PaymentNetwork.hpp"
+#include "PaymentResult.hpp"
+#include "PaymentToken.hpp"
+#include <NitroModules/FastVectorCopy.hpp>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace margelo::nitro::pay::bridge::swift {
+
+  // pragma MARK: std::function<void()>
+  /**
+   * Specialized version of `std::function<void()>`.
+   */
+  using Func_void = std::function<void()>;
+  /**
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   */
+  class Func_void_Wrapper final {
+  public:
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const noexcept {
+      _function->operator()();
+    }
+  private:
+    std::unique_ptr<std::function<void()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
+    return Func_void_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void()>>
+  /**
+   * Specialized version of `std::optional<std::function<void()>>`.
+   */
+  using std__optional_std__function_void____ = std::optional<std::function<void()>>;
+  inline std::optional<std::function<void()>> create_std__optional_std__function_void____(const std::function<void()>& value) noexcept {
+    return std::optional<std::function<void()>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void____(const std::optional<std::function<void()>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void()> get_std__optional_std__function_void____(const std::optional<std::function<void()>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridApplePayButtonSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridApplePayButtonSpec>`.
+   */
+  using std__shared_ptr_HybridApplePayButtonSpec_ = std::shared_ptr<HybridApplePayButtonSpec>;
+  std::shared_ptr<HybridApplePayButtonSpec> create_std__shared_ptr_HybridApplePayButtonSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridApplePayButtonSpec_(std__shared_ptr_HybridApplePayButtonSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridApplePayButtonSpec>
+  using std__weak_ptr_HybridApplePayButtonSpec_ = std::weak_ptr<HybridApplePayButtonSpec>;
+  inline std__weak_ptr_HybridApplePayButtonSpec_ weakify_std__shared_ptr_HybridApplePayButtonSpec_(const std::shared_ptr<HybridApplePayButtonSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<PaymentNetwork>
+  /**
+   * Specialized version of `std::optional<PaymentNetwork>`.
+   */
+  using std__optional_PaymentNetwork_ = std::optional<PaymentNetwork>;
+  inline std::optional<PaymentNetwork> create_std__optional_PaymentNetwork_(const PaymentNetwork& value) noexcept {
+    return std::optional<PaymentNetwork>(value);
+  }
+  inline bool has_value_std__optional_PaymentNetwork_(const std::optional<PaymentNetwork>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline PaymentNetwork get_std__optional_PaymentNetwork_(const std::optional<PaymentNetwork>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<PKSecureElementPass>
+  /**
+   * Specialized version of `std::optional<PKSecureElementPass>`.
+   */
+  using std__optional_PKSecureElementPass_ = std::optional<PKSecureElementPass>;
+  inline std::optional<PKSecureElementPass> create_std__optional_PKSecureElementPass_(const PKSecureElementPass& value) noexcept {
+    return std::optional<PKSecureElementPass>(value);
+  }
+  inline bool has_value_std__optional_PKSecureElementPass_(const std::optional<PKSecureElementPass>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline PKSecureElementPass get_std__optional_PKSecureElementPass_(const std::optional<PKSecureElementPass>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<CNLabeledPhoneNumber>
+  /**
+   * Specialized version of `std::vector<CNLabeledPhoneNumber>`.
+   */
+  using std__vector_CNLabeledPhoneNumber_ = std::vector<CNLabeledPhoneNumber>;
+  inline std::vector<CNLabeledPhoneNumber> create_std__vector_CNLabeledPhoneNumber_(size_t size) noexcept {
+    std::vector<CNLabeledPhoneNumber> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<CNLabeledEmailAddress>
+  /**
+   * Specialized version of `std::vector<CNLabeledEmailAddress>`.
+   */
+  using std__vector_CNLabeledEmailAddress_ = std::vector<CNLabeledEmailAddress>;
+  inline std::vector<CNLabeledEmailAddress> create_std__vector_CNLabeledEmailAddress_(size_t size) noexcept {
+    std::vector<CNLabeledEmailAddress> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<CNLabeledPostalAddress>
+  /**
+   * Specialized version of `std::vector<CNLabeledPostalAddress>`.
+   */
+  using std__vector_CNLabeledPostalAddress_ = std::vector<CNLabeledPostalAddress>;
+  inline std::vector<CNLabeledPostalAddress> create_std__vector_CNLabeledPostalAddress_(size_t size) noexcept {
+    std::vector<CNLabeledPostalAddress> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<CNContact>
+  /**
+   * Specialized version of `std::optional<CNContact>`.
+   */
+  using std__optional_CNContact_ = std::optional<CNContact>;
+  inline std::optional<CNContact> create_std__optional_CNContact_(const CNContact& value) noexcept {
+    return std::optional<CNContact>(value);
+  }
+  inline bool has_value_std__optional_CNContact_(const std::optional<CNContact>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline CNContact get_std__optional_CNContact_(const std::optional<CNContact>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<PaymentToken>
+  /**
+   * Specialized version of `std::optional<PaymentToken>`.
+   */
+  using std__optional_PaymentToken_ = std::optional<PaymentToken>;
+  inline std::optional<PaymentToken> create_std__optional_PaymentToken_(const PaymentToken& value) noexcept {
+    return std::optional<PaymentToken>(value);
+  }
+  inline bool has_value_std__optional_PaymentToken_(const std::optional<PaymentToken>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline PaymentToken get_std__optional_PaymentToken_(const std::optional<PaymentToken>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<PaymentResult>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<PaymentResult>>`.
+   */
+  using std__shared_ptr_Promise_PaymentResult__ = std::shared_ptr<Promise<PaymentResult>>;
+  inline std::shared_ptr<Promise<PaymentResult>> create_std__shared_ptr_Promise_PaymentResult__() noexcept {
+    return Promise<PaymentResult>::create();
+  }
+  inline PromiseHolder<PaymentResult> wrap_std__shared_ptr_Promise_PaymentResult__(std::shared_ptr<Promise<PaymentResult>> promise) noexcept {
+    return PromiseHolder<PaymentResult>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const PaymentResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const PaymentResult&)>`.
+   */
+  using Func_void_PaymentResult = std::function<void(const PaymentResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const PaymentResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_PaymentResult_Wrapper final {
+  public:
+    explicit Func_void_PaymentResult_Wrapper(std::function<void(const PaymentResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const PaymentResult& /* result */)>>(std::move(func))) {}
+    inline void call(PaymentResult result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const PaymentResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PaymentResult create_Func_void_PaymentResult(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PaymentResult_Wrapper wrap_Func_void_PaymentResult(Func_void_PaymentResult value) noexcept {
+    return Func_void_PaymentResult_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
+   */
+  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__exception_ptr_Wrapper final {
+  public:
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    inline void call(std::exception_ptr error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
+    return Func_void_std__exception_ptr_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<PaymentItem>
+  /**
+   * Specialized version of `std::vector<PaymentItem>`.
+   */
+  using std__vector_PaymentItem_ = std::vector<PaymentItem>;
+  inline std::vector<PaymentItem> create_std__vector_PaymentItem_(size_t size) noexcept {
+    std::vector<PaymentItem> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<std::string>
+  /**
+   * Specialized version of `std::vector<std::string>`.
+   */
+  using std__vector_std__string_ = std::vector<std::string>;
+  inline std::vector<std::string> create_std__vector_std__string_(size_t size) noexcept {
+    std::vector<std::string> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<PaymentItem>>
+  /**
+   * Specialized version of `std::optional<std::vector<PaymentItem>>`.
+   */
+  using std__optional_std__vector_PaymentItem__ = std::optional<std::vector<PaymentItem>>;
+  inline std::optional<std::vector<PaymentItem>> create_std__optional_std__vector_PaymentItem__(const std::vector<PaymentItem>& value) noexcept {
+    return std::optional<std::vector<PaymentItem>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_PaymentItem__(const std::optional<std::vector<PaymentItem>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<PaymentItem> get_std__optional_std__vector_PaymentItem__(const std::optional<std::vector<PaymentItem>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<GooglePayEnvironment>
+  /**
+   * Specialized version of `std::optional<GooglePayEnvironment>`.
+   */
+  using std__optional_GooglePayEnvironment_ = std::optional<GooglePayEnvironment>;
+  inline std::optional<GooglePayEnvironment> create_std__optional_GooglePayEnvironment_(const GooglePayEnvironment& value) noexcept {
+    return std::optional<GooglePayEnvironment>(value);
+  }
+  inline bool has_value_std__optional_GooglePayEnvironment_(const std::optional<GooglePayEnvironment>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline GooglePayEnvironment get_std__optional_GooglePayEnvironment_(const std::optional<GooglePayEnvironment>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridPaymentHandlerSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridPaymentHandlerSpec>`.
+   */
+  using std__shared_ptr_HybridPaymentHandlerSpec_ = std::shared_ptr<HybridPaymentHandlerSpec>;
+  std::shared_ptr<HybridPaymentHandlerSpec> create_std__shared_ptr_HybridPaymentHandlerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridPaymentHandlerSpec_(std__shared_ptr_HybridPaymentHandlerSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridPaymentHandlerSpec>
+  using std__weak_ptr_HybridPaymentHandlerSpec_ = std::weak_ptr<HybridPaymentHandlerSpec>;
+  inline std__weak_ptr_HybridPaymentHandlerSpec_ weakify_std__shared_ptr_HybridPaymentHandlerSpec_(const std::shared_ptr<HybridPaymentHandlerSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<PayServiceStatus>
+  using Result_PayServiceStatus_ = Result<PayServiceStatus>;
+  inline Result_PayServiceStatus_ create_Result_PayServiceStatus_(const PayServiceStatus& value) noexcept {
+    return Result<PayServiceStatus>::withValue(value);
+  }
+  inline Result_PayServiceStatus_ create_Result_PayServiceStatus_(const std::exception_ptr& error) noexcept {
+    return Result<PayServiceStatus>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<PaymentResult>>>
+  using Result_std__shared_ptr_Promise_PaymentResult___ = Result<std::shared_ptr<Promise<PaymentResult>>>;
+  inline Result_std__shared_ptr_Promise_PaymentResult___ create_Result_std__shared_ptr_Promise_PaymentResult___(const std::shared_ptr<Promise<PaymentResult>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<PaymentResult>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_PaymentResult___ create_Result_std__shared_ptr_Promise_PaymentResult___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<PaymentResult>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
+    return Result<bool>::withValue(std::move(value));
+  }
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
+    return Result<bool>::withError(error);
+  }
+
+} // namespace margelo::nitro::pay::bridge::swift

package/nitrogen/generated/ios/NitroPay-Swift-Cxx-Umbrella.hpp

@@ -0,0 +1,116 @@
+///
+/// NitroPay-Swift-Cxx-Umbrella.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `ApplePayButtonStyle` to properly resolve imports.
+namespace margelo::nitro::pay { enum class ApplePayButtonStyle; }
+// Forward declaration of `ApplePayButtonType` to properly resolve imports.
+namespace margelo::nitro::pay { enum class ApplePayButtonType; }
+// Forward declaration of `CNContactType` to properly resolve imports.
+namespace margelo::nitro::pay { enum class CNContactType; }
+// Forward declaration of `CNContact` to properly resolve imports.
+namespace margelo::nitro::pay { struct CNContact; }
+// Forward declaration of `CNLabeledEmailAddress` to properly resolve imports.
+namespace margelo::nitro::pay { struct CNLabeledEmailAddress; }
+// Forward declaration of `CNLabeledPhoneNumber` to properly resolve imports.
+namespace margelo::nitro::pay { struct CNLabeledPhoneNumber; }
+// Forward declaration of `CNLabeledPostalAddress` to properly resolve imports.
+namespace margelo::nitro::pay { struct CNLabeledPostalAddress; }
+// Forward declaration of `CNPhoneNumber` to properly resolve imports.
+namespace margelo::nitro::pay { struct CNPhoneNumber; }
+// Forward declaration of `CNPostalAddress` to properly resolve imports.
+namespace margelo::nitro::pay { struct CNPostalAddress; }
+// Forward declaration of `GooglePayEnvironment` to properly resolve imports.
+namespace margelo::nitro::pay { enum class GooglePayEnvironment; }
+// Forward declaration of `HybridApplePayButtonSpec` to properly resolve imports.
+namespace margelo::nitro::pay { class HybridApplePayButtonSpec; }
+// Forward declaration of `HybridPaymentHandlerSpec` to properly resolve imports.
+namespace margelo::nitro::pay { class HybridPaymentHandlerSpec; }
+// Forward declaration of `PKSecureElementPass` to properly resolve imports.
+namespace margelo::nitro::pay { struct PKSecureElementPass; }
+// Forward declaration of `PassActivationState` to properly resolve imports.
+namespace margelo::nitro::pay { enum class PassActivationState; }
+// Forward declaration of `PayServiceStatus` to properly resolve imports.
+namespace margelo::nitro::pay { struct PayServiceStatus; }
+// Forward declaration of `PaymentItemType` to properly resolve imports.
+namespace margelo::nitro::pay { enum class PaymentItemType; }
+// Forward declaration of `PaymentItem` to properly resolve imports.
+namespace margelo::nitro::pay { struct PaymentItem; }
+// Forward declaration of `PaymentMethodType` to properly resolve imports.
+namespace margelo::nitro::pay { enum class PaymentMethodType; }
+// Forward declaration of `PaymentMethod` to properly resolve imports.
+namespace margelo::nitro::pay { struct PaymentMethod; }
+// Forward declaration of `PaymentNetwork` to properly resolve imports.
+namespace margelo::nitro::pay { enum class PaymentNetwork; }
+// Forward declaration of `PaymentRequest` to properly resolve imports.
+namespace margelo::nitro::pay { struct PaymentRequest; }
+// Forward declaration of `PaymentResult` to properly resolve imports.
+namespace margelo::nitro::pay { struct PaymentResult; }
+// Forward declaration of `PaymentToken` to properly resolve imports.
+namespace margelo::nitro::pay { struct PaymentToken; }
+
+// Include C++ defined types
+#include "ApplePayButtonStyle.hpp"
+#include "ApplePayButtonType.hpp"
+#include "CNContact.hpp"
+#include "CNContactType.hpp"
+#include "CNLabeledEmailAddress.hpp"
+#include "CNLabeledPhoneNumber.hpp"
+#include "CNLabeledPostalAddress.hpp"
+#include "CNPhoneNumber.hpp"
+#include "CNPostalAddress.hpp"
+#include "GooglePayEnvironment.hpp"
+#include "HybridApplePayButtonSpec.hpp"
+#include "HybridPaymentHandlerSpec.hpp"
+#include "PKSecureElementPass.hpp"
+#include "PassActivationState.hpp"
+#include "PayServiceStatus.hpp"
+#include "PaymentItem.hpp"
+#include "PaymentItemType.hpp"
+#include "PaymentMethod.hpp"
+#include "PaymentMethodType.hpp"
+#include "PaymentNetwork.hpp"
+#include "PaymentRequest.hpp"
+#include "PaymentResult.hpp"
+#include "PaymentToken.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+// C++ helpers for Swift
+#include "NitroPay-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridApplePayButtonSpec_cxx` to properly resolve imports.
+namespace NitroPay { class HybridApplePayButtonSpec_cxx; }
+// Forward declaration of `HybridPaymentHandlerSpec_cxx` to properly resolve imports.
+namespace NitroPay { class HybridPaymentHandlerSpec_cxx; }
+
+// Include Swift defined types
+#if __has_include("NitroPay-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "NitroPay".
+#include "NitroPay-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<NitroPay/NitroPay-Swift.h>)
+#include <NitroPay/NitroPay-Swift.h>
+#else
+#error NitroPay's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "NitroPay", and try building the app first.
+#endif

package/nitrogen/generated/ios/NitroPayAutolinking.mm

@@ -0,0 +1,41 @@
+///
+/// NitroPayAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+#import "NitroPay-Swift-Cxx-Umbrella.hpp"
+#import <type_traits>
+
+#include "HybridApplePayButtonSpecSwift.hpp"
+#include "HybridPaymentHandlerSpecSwift.hpp"
+
+@interface NitroPayAutolinking : NSObject
+@end
+
+@implementation NitroPayAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::pay;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ApplePayButton",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridApplePayButtonSpec> hybridObject = NitroPay::NitroPayAutolinking::createApplePayButton();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "PaymentHandler",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridPaymentHandlerSpec> hybridObject = NitroPay::NitroPayAutolinking::createPaymentHandler();
+      return hybridObject;
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/NitroPayAutolinking.swift

@@ -0,0 +1,40 @@
+///
+/// NitroPayAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+public final class NitroPayAutolinking {
+  public typealias bridge = margelo.nitro.pay.bridge.swift
+
+  /**
+   * Creates an instance of a Swift class that implements `HybridApplePayButtonSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridApplePayButtonSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridApplePayButton`).
+   */
+  public static func createApplePayButton() -> bridge.std__shared_ptr_HybridApplePayButtonSpec_ {
+    let hybridObject = HybridApplePayButton()
+    return { () -> bridge.std__shared_ptr_HybridApplePayButtonSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridPaymentHandlerSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridPaymentHandlerSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridPaymentHandler`).
+   */
+  public static func createPaymentHandler() -> bridge.std__shared_ptr_HybridPaymentHandlerSpec_ {
+    let hybridObject = HybridPaymentHandler()
+    return { () -> bridge.std__shared_ptr_HybridPaymentHandlerSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+}

package/nitrogen/generated/ios/c++/HybridApplePayButtonSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridApplePayButtonSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridApplePayButtonSpecSwift.hpp"
+
+namespace margelo::nitro::pay {
+} // namespace margelo::nitro::pay