@onramper/onramper-react-native 1.0.1

package/lib/typescript/module/src/types.d.ts

@@ -0,0 +1,127 @@
+import type { OnramperErrorPayload } from './errors';
+export type OnramperEnvironment = 'development' | 'production';
+export type OnramperLogLevel = 'off' | 'error' | 'info' | 'debug';
+export type OnramperTheme = 'system' | 'light' | 'dark';
+export type TransactionType = 'buy' | 'sell';
+export interface SessionCredentials {
+    sessionId: string;
+    sessionToken: string;
+}
+export interface OnramperConfiguration {
+    apiKey: string;
+    clientId: string;
+    environment: OnramperEnvironment;
+    theme?: OnramperTheme;
+    logLevel?: OnramperLogLevel;
+    /**
+     * Called by the SDK when the session token expires and needs to be re-issued.
+     *
+     * May be synchronous or async — under the hood the bridge uses an event
+     * round-trip (`onSessionExpired` → `provideSessionCredentials`) so Promises
+     * are awaited normally. Throw or reject to signal that no fresh credentials
+     * are available; the SDK will surface `userTokenRefreshFailed`.
+     */
+    onSessionExpired: () => SessionCredentials | Promise<SessionCredentials>;
+}
+export interface WalletInfo {
+    network: string;
+    address: string;
+    memo?: string;
+}
+export interface CheckoutRequest {
+    source: string;
+    destination?: string;
+    amount: number;
+    type: TransactionType;
+    country?: string;
+    subdivision?: string;
+    paymentMethod: string;
+    wallet: WalletInfo;
+    onlyOnramps?: string[];
+}
+export interface QuoteResponse {
+    quoteId?: string;
+    ramp?: string;
+    rate?: number;
+    networkFee?: number;
+    transactionFee?: number;
+    payout?: number;
+    paymentMethod?: string;
+    recommendations?: string[];
+    errors?: QuoteError[];
+}
+export interface QuoteError {
+    type: string;
+    message: string;
+}
+export interface CheckoutButtonStyle {
+    backgroundColor?: string;
+    foregroundColor?: string;
+    borderRadius?: number;
+}
+export type RenderType = 'webview' | 'deeplink';
+export type CheckoutPaymentType = 'applepay' | 'revolutpay';
+export interface HeadlessCheckoutData {
+    checkoutPaymentType: CheckoutPaymentType;
+    url: string;
+    renderType: RenderType;
+}
+export interface CheckoutFinalizeResponse {
+    headlessCheckoutId: string;
+    headlessCheckoutData: HeadlessCheckoutData;
+}
+export type CheckoutRequirement = {
+    type: 'tos';
+    providerId: string;
+    items: ToSItem[];
+} | {
+    type: 'amount_limit';
+    providerId: string;
+    minAmountLimit?: number;
+    maxAmountLimit?: number;
+} | {
+    type: 'user_info';
+    providerId: string;
+    fields: UserInfoField[];
+};
+export interface ToSItem {
+    type: 'tos' | 'privacy_policy' | 'user_agreement';
+    required: boolean;
+    satisfied: boolean;
+    url?: string;
+    content?: string;
+}
+export interface UserInfoField {
+    type: string;
+    required: boolean;
+}
+export type OnramperState = {
+    kind: 'idle';
+} | {
+    kind: 'initializing';
+} | {
+    kind: 'ready';
+} | {
+    kind: 'checkoutPreparing';
+} | {
+    kind: 'requireLogin';
+    requirements: CheckoutRequirement[];
+} | {
+    kind: 'authenticating';
+} | {
+    kind: 'readyToCheckout';
+} | {
+    kind: 'finalizing';
+} | {
+    kind: 'rendering';
+    url: string;
+    renderType: RenderType;
+    paymentType: CheckoutPaymentType;
+} | {
+    kind: 'completed';
+} | {
+    kind: 'failed';
+    error: OnramperErrorPayload;
+};
+export type { OnramperErrorPayload };
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/module/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/types.ts"],"names":[],"mappings":"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"}

package/nitro.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": ["onramper"],
+  "ios": {
+    "iosModuleName": "OnramperReactNative"
+  },
+  "android": {
+    "androidNamespace": ["onramper"],
+    "androidCxxLibName": "OnramperReactNative"
+  },
+  "autolinking": {
+    "OnramperNitro": {
+      "ios": { "language": "swift", "implementationClassName": "HybridOnramperNitro" }
+    },
+    "OnramperCheckoutButton": {
+      "ios": { "language": "swift", "implementationClassName": "HybridOnramperCheckoutButton" }
+    }
+  }
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/nitrogen/generated/ios/OnramperReactNative+autolinking.rb

@@ -0,0 +1,62 @@
+#
+# OnramperReactNative+autolinking.rb
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a Ruby script that adds all files generated by Nitrogen
+# to the given podspec.
+#
+# To use it, add this to your .podspec:
+# ```ruby
+# Pod::Spec.new do |spec|
+#   # ...
+#
+#   # Add all files generated by Nitrogen
+#   load 'nitrogen/generated/ios/OnramperReactNative+autolinking.rb'
+#   add_nitrogen_files(spec)
+# end
+# ```
+
+def add_nitrogen_files(spec)
+  Pod::UI.puts "[NitroModules] 🔥 OnramperReactNative is boosted by nitro!"
+
+  spec.dependency "NitroModules"
+
+  current_source_files = Array(spec.attributes_hash['source_files'])
+  spec.source_files = current_source_files + [
+    # Generated cross-platform specs
+    "nitrogen/generated/shared/**/*.{h,hpp,c,cpp,swift}",
+    # Generated bridges for the cross-platform specs
+    "nitrogen/generated/ios/**/*.{h,hpp,c,cpp,mm,swift}",
+  ]
+
+  current_public_header_files = Array(spec.attributes_hash['public_header_files'])
+  spec.public_header_files = current_public_header_files + [
+    # Generated specs
+    "nitrogen/generated/shared/**/*.{h,hpp}",
+    # Swift to C++ bridging helpers
+    "nitrogen/generated/ios/OnramperReactNative-Swift-Cxx-Bridge.hpp"
+  ]
+
+  current_private_header_files = Array(spec.attributes_hash['private_header_files'])
+  spec.private_header_files = current_private_header_files + [
+    # iOS specific specs
+    "nitrogen/generated/ios/c++/**/*.{h,hpp}",
+    # Views are framework-specific and should be private
+    "nitrogen/generated/shared/**/views/**/*"
+  ]
+
+  current_pod_target_xcconfig = spec.attributes_hash['pod_target_xcconfig'] || {}
+  spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
+    # Use C++ 20
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    # Enables C++ <-> Swift interop (by default it's only ObjC)
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+    # Enables stricter modular headers
+    "DEFINES_MODULE" => "YES",
+    # Disable auto-generated ObjC header for Swift (Static linkage on Xcode 26.4 breaks here)
+    "SWIFT_INSTALL_OBJC_HEADER" => "NO",
+  })
+end

package/nitrogen/generated/ios/OnramperReactNative-Swift-Cxx-Bridge.cpp

@@ -0,0 +1,107 @@
+///
+/// OnramperReactNative-Swift-Cxx-Bridge.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "OnramperReactNative-Swift-Cxx-Bridge.hpp"
+
+// Include C++ implementation defined types
+#include "HybridOnramperCheckoutButtonSpecSwift.hpp"
+#include "HybridOnramperNitroSpecSwift.hpp"
+#include "OnramperReactNative-Swift-Cxx-Umbrella.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::onramper::bridge::swift {
+
+  // pragma MARK: std::shared_ptr<HybridOnramperCheckoutButtonSpec>
+  std::shared_ptr<HybridOnramperCheckoutButtonSpec> create_std__shared_ptr_HybridOnramperCheckoutButtonSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    OnramperReactNative::HybridOnramperCheckoutButtonSpec_cxx swiftPart = OnramperReactNative::HybridOnramperCheckoutButtonSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::onramper::HybridOnramperCheckoutButtonSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridOnramperCheckoutButtonSpec_(std__shared_ptr_HybridOnramperCheckoutButtonSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::onramper::HybridOnramperCheckoutButtonSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::onramper::HybridOnramperCheckoutButtonSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridOnramperCheckoutButtonSpec\" is not implemented in Swift!");
+    }
+    #endif
+    OnramperReactNative::HybridOnramperCheckoutButtonSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
+  // pragma MARK: std::function<void()>
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = OnramperReactNative::Func_void::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
+      swiftClosure.call();
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = OnramperReactNative::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::exception_ptr& error) mutable -> void {
+      swiftClosure.call(error);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const PreparedIntentResult& /* result */)>
+  Func_void_PreparedIntentResult create_Func_void_PreparedIntentResult(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = OnramperReactNative::Func_void_PreparedIntentResult::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const PreparedIntentResult& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* stateJson */)>
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = OnramperReactNative::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::string& stateJson) mutable -> void {
+      swiftClosure.call(stateJson);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const NitroSessionCredentials& /* result */)>
+  Func_void_NitroSessionCredentials create_Func_void_NitroSessionCredentials(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = OnramperReactNative::Func_void_NitroSessionCredentials::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const NitroSessionCredentials& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>>()>
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials____ create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials____(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = OnramperReactNative::Func_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials____::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)]() mutable -> std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>> {
+      auto __result = swiftClosure.call();
+      return __result;
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<NitroSessionCredentials>>& /* result */)>
+  Func_void_std__shared_ptr_Promise_NitroSessionCredentials__ create_Func_void_std__shared_ptr_Promise_NitroSessionCredentials__(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = OnramperReactNative::Func_void_std__shared_ptr_Promise_NitroSessionCredentials__::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<Promise<NitroSessionCredentials>>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridOnramperNitroSpec>
+  std::shared_ptr<HybridOnramperNitroSpec> create_std__shared_ptr_HybridOnramperNitroSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    OnramperReactNative::HybridOnramperNitroSpec_cxx swiftPart = OnramperReactNative::HybridOnramperNitroSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::onramper::HybridOnramperNitroSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridOnramperNitroSpec_(std__shared_ptr_HybridOnramperNitroSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::onramper::HybridOnramperNitroSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::onramper::HybridOnramperNitroSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridOnramperNitroSpec\" is not implemented in Swift!");
+    }
+    #endif
+    OnramperReactNative::HybridOnramperNitroSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+
+} // namespace margelo::nitro::onramper::bridge::swift

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

@@ -0,0 +1,299 @@
+///
+/// OnramperReactNative-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `HybridOnramperCheckoutButtonSpec` to properly resolve imports.
+namespace margelo::nitro::onramper { class HybridOnramperCheckoutButtonSpec; }
+// Forward declaration of `HybridOnramperNitroSpec` to properly resolve imports.
+namespace margelo::nitro::onramper { class HybridOnramperNitroSpec; }
+// Forward declaration of `NitroSessionCredentials` to properly resolve imports.
+namespace margelo::nitro::onramper { struct NitroSessionCredentials; }
+// Forward declaration of `PreparedIntentResult` to properly resolve imports.
+namespace margelo::nitro::onramper { struct PreparedIntentResult; }
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridOnramperCheckoutButtonSpec_cxx` to properly resolve imports.
+namespace OnramperReactNative { class HybridOnramperCheckoutButtonSpec_cxx; }
+// Forward declaration of `HybridOnramperNitroSpec_cxx` to properly resolve imports.
+namespace OnramperReactNative { class HybridOnramperNitroSpec_cxx; }
+
+// Include C++ defined types
+#include "HybridOnramperCheckoutButtonSpec.hpp"
+#include "HybridOnramperNitroSpec.hpp"
+#include "NitroSessionCredentials.hpp"
+#include "PreparedIntentResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <string>
+
+/**
+ * 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::onramper::bridge::swift {
+
+  // pragma MARK: std::shared_ptr<HybridOnramperCheckoutButtonSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridOnramperCheckoutButtonSpec>`.
+   */
+  using std__shared_ptr_HybridOnramperCheckoutButtonSpec_ = std::shared_ptr<HybridOnramperCheckoutButtonSpec>;
+  std::shared_ptr<HybridOnramperCheckoutButtonSpec> create_std__shared_ptr_HybridOnramperCheckoutButtonSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridOnramperCheckoutButtonSpec_(std__shared_ptr_HybridOnramperCheckoutButtonSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridOnramperCheckoutButtonSpec>
+  using std__weak_ptr_HybridOnramperCheckoutButtonSpec_ = std::weak_ptr<HybridOnramperCheckoutButtonSpec>;
+  inline std__weak_ptr_HybridOnramperCheckoutButtonSpec_ weakify_std__shared_ptr_HybridOnramperCheckoutButtonSpec_(const std::shared_ptr<HybridOnramperCheckoutButtonSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::shared_ptr<Promise<void>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
+   */
+  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
+    return Promise<void>::create();
+  }
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
+    return PromiseHolder<void>(std::move(promise));
+  }
+  
+  // 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::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::shared_ptr<Promise<PreparedIntentResult>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<PreparedIntentResult>>`.
+   */
+  using std__shared_ptr_Promise_PreparedIntentResult__ = std::shared_ptr<Promise<PreparedIntentResult>>;
+  inline std::shared_ptr<Promise<PreparedIntentResult>> create_std__shared_ptr_Promise_PreparedIntentResult__() noexcept {
+    return Promise<PreparedIntentResult>::create();
+  }
+  inline PromiseHolder<PreparedIntentResult> wrap_std__shared_ptr_Promise_PreparedIntentResult__(std::shared_ptr<Promise<PreparedIntentResult>> promise) noexcept {
+    return PromiseHolder<PreparedIntentResult>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const PreparedIntentResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const PreparedIntentResult&)>`.
+   */
+  using Func_void_PreparedIntentResult = std::function<void(const PreparedIntentResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const PreparedIntentResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_PreparedIntentResult_Wrapper final {
+  public:
+    explicit Func_void_PreparedIntentResult_Wrapper(std::function<void(const PreparedIntentResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const PreparedIntentResult& /* result */)>>(std::move(func))) {}
+    inline void call(PreparedIntentResult result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const PreparedIntentResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PreparedIntentResult create_Func_void_PreparedIntentResult(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PreparedIntentResult_Wrapper wrap_Func_void_PreparedIntentResult(Func_void_PreparedIntentResult value) noexcept {
+    return Func_void_PreparedIntentResult_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* stateJson */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&)>`.
+   */
+  using Func_void_std__string = std::function<void(const std::string& /* stateJson */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * stateJson * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_Wrapper final {
+  public:
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* stateJson */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* stateJson */)>>(std::move(func))) {}
+    inline void call(std::string stateJson) const noexcept {
+      _function->operator()(stateJson);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* stateJson */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept {
+    return Func_void_std__string_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<NitroSessionCredentials>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<NitroSessionCredentials>>`.
+   */
+  using std__shared_ptr_Promise_NitroSessionCredentials__ = std::shared_ptr<Promise<NitroSessionCredentials>>;
+  inline std::shared_ptr<Promise<NitroSessionCredentials>> create_std__shared_ptr_Promise_NitroSessionCredentials__() noexcept {
+    return Promise<NitroSessionCredentials>::create();
+  }
+  inline PromiseHolder<NitroSessionCredentials> wrap_std__shared_ptr_Promise_NitroSessionCredentials__(std::shared_ptr<Promise<NitroSessionCredentials>> promise) noexcept {
+    return PromiseHolder<NitroSessionCredentials>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const NitroSessionCredentials& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const NitroSessionCredentials&)>`.
+   */
+  using Func_void_NitroSessionCredentials = std::function<void(const NitroSessionCredentials& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const NitroSessionCredentials& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_NitroSessionCredentials_Wrapper final {
+  public:
+    explicit Func_void_NitroSessionCredentials_Wrapper(std::function<void(const NitroSessionCredentials& /* result */)>&& func): _function(std::make_unique<std::function<void(const NitroSessionCredentials& /* result */)>>(std::move(func))) {}
+    inline void call(NitroSessionCredentials result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const NitroSessionCredentials& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_NitroSessionCredentials create_Func_void_NitroSessionCredentials(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_NitroSessionCredentials_Wrapper wrap_Func_void_NitroSessionCredentials(Func_void_NitroSessionCredentials value) noexcept {
+    return Func_void_NitroSessionCredentials_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>>()>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>>()>`.
+   */
+  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials____ = std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>>()>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>>()>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials_____Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials_____Wrapper(std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>>()>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>>()>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>> call() const noexcept {
+      auto __result = _function->operator()();
+      return __result;
+    }
+  private:
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>>()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials____ create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials____(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials_____Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials____(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials____ value) noexcept {
+    return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials_____Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials____ = std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>> create_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials____() noexcept {
+    return Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<Promise<NitroSessionCredentials>>> wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_NitroSessionCredentials____(std::shared_ptr<Promise<std::shared_ptr<Promise<NitroSessionCredentials>>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<Promise<NitroSessionCredentials>>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<NitroSessionCredentials>>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<Promise<NitroSessionCredentials>>&)>`.
+   */
+  using Func_void_std__shared_ptr_Promise_NitroSessionCredentials__ = std::function<void(const std::shared_ptr<Promise<NitroSessionCredentials>>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<Promise<NitroSessionCredentials>>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_Promise_NitroSessionCredentials___Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_Promise_NitroSessionCredentials___Wrapper(std::function<void(const std::shared_ptr<Promise<NitroSessionCredentials>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<Promise<NitroSessionCredentials>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<Promise<NitroSessionCredentials>> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<Promise<NitroSessionCredentials>>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_Promise_NitroSessionCredentials__ create_Func_void_std__shared_ptr_Promise_NitroSessionCredentials__(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_Promise_NitroSessionCredentials___Wrapper wrap_Func_void_std__shared_ptr_Promise_NitroSessionCredentials__(Func_void_std__shared_ptr_Promise_NitroSessionCredentials__ value) noexcept {
+    return Func_void_std__shared_ptr_Promise_NitroSessionCredentials___Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridOnramperNitroSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridOnramperNitroSpec>`.
+   */
+  using std__shared_ptr_HybridOnramperNitroSpec_ = std::shared_ptr<HybridOnramperNitroSpec>;
+  std::shared_ptr<HybridOnramperNitroSpec> create_std__shared_ptr_HybridOnramperNitroSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridOnramperNitroSpec_(std__shared_ptr_HybridOnramperNitroSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridOnramperNitroSpec>
+  using std__weak_ptr_HybridOnramperNitroSpec_ = std::weak_ptr<HybridOnramperNitroSpec>;
+  inline std__weak_ptr_HybridOnramperNitroSpec_ weakify_std__shared_ptr_HybridOnramperNitroSpec_(const std::shared_ptr<HybridOnramperNitroSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<void>>>
+  using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<PreparedIntentResult>>>
+  using Result_std__shared_ptr_Promise_PreparedIntentResult___ = Result<std::shared_ptr<Promise<PreparedIntentResult>>>;
+  inline Result_std__shared_ptr_Promise_PreparedIntentResult___ create_Result_std__shared_ptr_Promise_PreparedIntentResult___(const std::shared_ptr<Promise<PreparedIntentResult>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<PreparedIntentResult>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_PreparedIntentResult___ create_Result_std__shared_ptr_Promise_PreparedIntentResult___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<PreparedIntentResult>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
+
+} // namespace margelo::nitro::onramper::bridge::swift