react-native-pos-pagseguro 1.0.0

package/nitrogen/generated/android/pospagseguroOnLoad.cpp

@@ -0,0 +1,46 @@
+///
+/// pospagseguroOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_POSPAGSEGURO_WITH_GENERATED_CMAKE_PROJECT
+#error pospagseguroOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "pospagseguroOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridPosPagseguroSpec.hpp"
+#include "JFunc_void_std__string.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::pospagseguro {
+
+int initialize(JavaVM* vm) {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::pospagseguro;
+  using namespace facebook;
+
+  return facebook::jni::initialize(vm, [] {
+    // Register native JNI methods
+    margelo::nitro::pospagseguro::JHybridPosPagseguroSpec::registerNatives();
+    margelo::nitro::pospagseguro::JFunc_void_std__string_cxx::registerNatives();
+
+    // Register Nitro Hybrid Objects
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "PosPagseguro",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridPosPagseguroSpec::javaobject> object("com/margelo/nitro/pospagseguro/PosPagseguro");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
+  });
+}
+
+} // namespace margelo::nitro::pospagseguro

package/nitrogen/generated/android/pospagseguroOnLoad.hpp

@@ -0,0 +1,25 @@
+///
+/// pospagseguroOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::pospagseguro {
+
+  /**
+   * Initializes the native (C++) part of pospagseguro, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`).
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return margelo::nitro::pospagseguro::initialize(vm);
+   * }
+   * ```
+   */
+  int initialize(JavaVM* vm);
+
+} // namespace margelo::nitro::pospagseguro

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

@@ -0,0 +1,60 @@
+#
+# PosPagseguro+autolinking.rb
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © 2026 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/PosPagseguro+autolinking.rb'
+#   add_nitrogen_files(spec)
+# end
+# ```
+
+def add_nitrogen_files(spec)
+  Pod::UI.puts "[NitroModules] 🔥 PosPagseguro 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/PosPagseguro-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",
+  })
+end

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

@@ -0,0 +1,65 @@
+///
+/// PosPagseguro-Swift-Cxx-Bridge.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "PosPagseguro-Swift-Cxx-Bridge.hpp"
+
+// Include C++ implementation defined types
+#include "HybridPosPagseguroSpecSwift.hpp"
+#include "PosPagseguro-Swift-Cxx-Umbrella.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::pospagseguro::bridge::swift {
+
+  // pragma MARK: std::function<void(const std::variant<double, CustomError>& /* result */)>
+  Func_void_std__variant_double__CustomError_ create_Func_void_std__variant_double__CustomError_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = PosPagseguro::Func_void_std__variant_double__CustomError_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::variant<double, CustomError>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // 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 = PosPagseguro::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 std::variant<CustomError, TransactionResult>& /* result */)>
+  Func_void_std__variant_CustomError__TransactionResult_ create_Func_void_std__variant_CustomError__TransactionResult_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = PosPagseguro::Func_void_std__variant_CustomError__TransactionResult_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::variant<CustomError, TransactionResult>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* event */)>
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = PosPagseguro::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::string& event) mutable -> void {
+      swiftClosure.call(event);
+    };
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridPosPagseguroSpec>
+  std::shared_ptr<HybridPosPagseguroSpec> create_std__shared_ptr_HybridPosPagseguroSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    PosPagseguro::HybridPosPagseguroSpec_cxx swiftPart = PosPagseguro::HybridPosPagseguroSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::pospagseguro::HybridPosPagseguroSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridPosPagseguroSpec_(std__shared_ptr_HybridPosPagseguroSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::pospagseguro::HybridPosPagseguroSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::pospagseguro::HybridPosPagseguroSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridPosPagseguroSpec\" is not implemented in Swift!");
+    }
+    #endif
+    PosPagseguro::HybridPosPagseguroSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+
+} // namespace margelo::nitro::pospagseguro::bridge::swift

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

@@ -0,0 +1,422 @@
+///
+/// PosPagseguro-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `CardIssuerNationality` to properly resolve imports.
+namespace margelo::nitro::pospagseguro { enum class CardIssuerNationality; }
+// Forward declaration of `CustomError` to properly resolve imports.
+namespace margelo::nitro::pospagseguro { struct CustomError; }
+// Forward declaration of `HybridPosPagseguroSpec` to properly resolve imports.
+namespace margelo::nitro::pospagseguro { class HybridPosPagseguroSpec; }
+// Forward declaration of `SubAcquirer` to properly resolve imports.
+namespace margelo::nitro::pospagseguro { struct SubAcquirer; }
+// Forward declaration of `TransactionResult` to properly resolve imports.
+namespace margelo::nitro::pospagseguro { struct TransactionResult; }
+// Forward declaration of `UserData` to properly resolve imports.
+namespace margelo::nitro::pospagseguro { struct UserData; }
+// Forward declaration of `VoidType` to properly resolve imports.
+namespace margelo::nitro::pospagseguro { enum class VoidType; }
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridPosPagseguroSpec_cxx` to properly resolve imports.
+namespace PosPagseguro { class HybridPosPagseguroSpec_cxx; }
+
+// Include C++ defined types
+#include "CardIssuerNationality.hpp"
+#include "CustomError.hpp"
+#include "HybridPosPagseguroSpec.hpp"
+#include "SubAcquirer.hpp"
+#include "TransactionResult.hpp"
+#include "UserData.hpp"
+#include "VoidType.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+
+/**
+ * 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::pospagseguro::bridge::swift {
+
+  // pragma MARK: std::optional<SubAcquirer>
+  /**
+   * Specialized version of `std::optional<SubAcquirer>`.
+   */
+  using std__optional_SubAcquirer_ = std::optional<SubAcquirer>;
+  inline std::optional<SubAcquirer> create_std__optional_SubAcquirer_(const SubAcquirer& value) noexcept {
+    return std::optional<SubAcquirer>(value);
+  }
+  inline bool has_value_std__optional_SubAcquirer_(const std::optional<SubAcquirer>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline SubAcquirer get_std__optional_SubAcquirer_(const std::optional<SubAcquirer>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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::variant<double, CustomError>
+  /**
+   * Wrapper struct for `std::variant<double, CustomError>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_double__CustomError_ final {
+    std::variant<double, CustomError> variant;
+    std__variant_double__CustomError_(std::variant<double, CustomError> variant): variant(variant) { }
+    operator std::variant<double, CustomError>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline double get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline CustomError get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_double__CustomError_ create_std__variant_double__CustomError_(double value) noexcept {
+    return std__variant_double__CustomError_(value);
+  }
+  inline std__variant_double__CustomError_ create_std__variant_double__CustomError_(const CustomError& value) noexcept {
+    return std__variant_double__CustomError_(value);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::variant<double, CustomError>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::variant<double, CustomError>>>`.
+   */
+  using std__shared_ptr_Promise_std__variant_double__CustomError___ = std::shared_ptr<Promise<std::variant<double, CustomError>>>;
+  inline std::shared_ptr<Promise<std::variant<double, CustomError>>> create_std__shared_ptr_Promise_std__variant_double__CustomError___() noexcept {
+    return Promise<std::variant<double, CustomError>>::create();
+  }
+  inline PromiseHolder<std::variant<double, CustomError>> wrap_std__shared_ptr_Promise_std__variant_double__CustomError___(std::shared_ptr<Promise<std::variant<double, CustomError>>> promise) noexcept {
+    return PromiseHolder<std::variant<double, CustomError>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::variant<double, CustomError>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::variant<double, CustomError>&)>`.
+   */
+  using Func_void_std__variant_double__CustomError_ = std::function<void(const std::variant<double, CustomError>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::variant<double, CustomError>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__variant_double__CustomError__Wrapper final {
+  public:
+    explicit Func_void_std__variant_double__CustomError__Wrapper(std::function<void(const std::variant<double, CustomError>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<double, CustomError>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<double, CustomError> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::variant<double, CustomError>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__variant_double__CustomError_ create_Func_void_std__variant_double__CustomError_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_double__CustomError__Wrapper wrap_Func_void_std__variant_double__CustomError_(Func_void_std__variant_double__CustomError_ value) noexcept {
+    return Func_void_std__variant_double__CustomError__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::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<CustomError>
+  /**
+   * Specialized version of `std::optional<CustomError>`.
+   */
+  using std__optional_CustomError_ = std::optional<CustomError>;
+  inline std::optional<CustomError> create_std__optional_CustomError_(const CustomError& value) noexcept {
+    return std::optional<CustomError>(value);
+  }
+  inline bool has_value_std__optional_CustomError_(const std::optional<CustomError>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline CustomError get_std__optional_CustomError_(const std::optional<CustomError>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<CardIssuerNationality>
+  /**
+   * Specialized version of `std::optional<CardIssuerNationality>`.
+   */
+  using std__optional_CardIssuerNationality_ = std::optional<CardIssuerNationality>;
+  inline std::optional<CardIssuerNationality> create_std__optional_CardIssuerNationality_(const CardIssuerNationality& value) noexcept {
+    return std::optional<CardIssuerNationality>(value);
+  }
+  inline bool has_value_std__optional_CardIssuerNationality_(const std::optional<CardIssuerNationality>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline CardIssuerNationality get_std__optional_CardIssuerNationality_(const std::optional<CardIssuerNationality>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::variant<CustomError, TransactionResult>
+  /**
+   * Wrapper struct for `std::variant<CustomError, TransactionResult>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_CustomError__TransactionResult_ final {
+    std::variant<CustomError, TransactionResult> variant;
+    std__variant_CustomError__TransactionResult_(std::variant<CustomError, TransactionResult> variant): variant(variant) { }
+    operator std::variant<CustomError, TransactionResult>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline CustomError get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline TransactionResult get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_CustomError__TransactionResult_ create_std__variant_CustomError__TransactionResult_(const CustomError& value) noexcept {
+    return std__variant_CustomError__TransactionResult_(value);
+  }
+  inline std__variant_CustomError__TransactionResult_ create_std__variant_CustomError__TransactionResult_(const TransactionResult& value) noexcept {
+    return std__variant_CustomError__TransactionResult_(value);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::variant<CustomError, TransactionResult>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::variant<CustomError, TransactionResult>>>`.
+   */
+  using std__shared_ptr_Promise_std__variant_CustomError__TransactionResult___ = std::shared_ptr<Promise<std::variant<CustomError, TransactionResult>>>;
+  inline std::shared_ptr<Promise<std::variant<CustomError, TransactionResult>>> create_std__shared_ptr_Promise_std__variant_CustomError__TransactionResult___() noexcept {
+    return Promise<std::variant<CustomError, TransactionResult>>::create();
+  }
+  inline PromiseHolder<std::variant<CustomError, TransactionResult>> wrap_std__shared_ptr_Promise_std__variant_CustomError__TransactionResult___(std::shared_ptr<Promise<std::variant<CustomError, TransactionResult>>> promise) noexcept {
+    return PromiseHolder<std::variant<CustomError, TransactionResult>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::variant<CustomError, TransactionResult>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::variant<CustomError, TransactionResult>&)>`.
+   */
+  using Func_void_std__variant_CustomError__TransactionResult_ = std::function<void(const std::variant<CustomError, TransactionResult>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::variant<CustomError, TransactionResult>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__variant_CustomError__TransactionResult__Wrapper final {
+  public:
+    explicit Func_void_std__variant_CustomError__TransactionResult__Wrapper(std::function<void(const std::variant<CustomError, TransactionResult>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<CustomError, TransactionResult>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<CustomError, TransactionResult> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::variant<CustomError, TransactionResult>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__variant_CustomError__TransactionResult_ create_Func_void_std__variant_CustomError__TransactionResult_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_CustomError__TransactionResult__Wrapper wrap_Func_void_std__variant_CustomError__TransactionResult_(Func_void_std__variant_CustomError__TransactionResult_ value) noexcept {
+    return Func_void_std__variant_CustomError__TransactionResult__Wrapper(std::move(value));
+  }
+  
+  // 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::function<void(const std::string& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&)>`.
+   */
+  using Func_void_std__string = std::function<void(const std::string& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * event * /)>`, 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& /* event */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* event */)>>(std::move(func))) {}
+    inline void call(std::string event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* event */)>> _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::optional<VoidType>
+  /**
+   * Specialized version of `std::optional<VoidType>`.
+   */
+  using std__optional_VoidType_ = std::optional<VoidType>;
+  inline std::optional<VoidType> create_std__optional_VoidType_(const VoidType& value) noexcept {
+    return std::optional<VoidType>(value);
+  }
+  inline bool has_value_std__optional_VoidType_(const std::optional<VoidType>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline VoidType get_std__optional_VoidType_(const std::optional<VoidType>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridPosPagseguroSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridPosPagseguroSpec>`.
+   */
+  using std__shared_ptr_HybridPosPagseguroSpec_ = std::shared_ptr<HybridPosPagseguroSpec>;
+  std::shared_ptr<HybridPosPagseguroSpec> create_std__shared_ptr_HybridPosPagseguroSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridPosPagseguroSpec_(std__shared_ptr_HybridPosPagseguroSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridPosPagseguroSpec>
+  using std__weak_ptr_HybridPosPagseguroSpec_ = std::weak_ptr<HybridPosPagseguroSpec>;
+  inline std__weak_ptr_HybridPosPagseguroSpec_ weakify_std__shared_ptr_HybridPosPagseguroSpec_(const std::shared_ptr<HybridPosPagseguroSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::string>
+  using Result_std__string_ = Result<std::string>;
+  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
+    return Result<std::string>::withValue(value);
+  }
+  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
+    return Result<std::string>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<SubAcquirer>>
+  using Result_std__optional_SubAcquirer__ = Result<std::optional<SubAcquirer>>;
+  inline Result_std__optional_SubAcquirer__ create_Result_std__optional_SubAcquirer__(const std::optional<SubAcquirer>& value) noexcept {
+    return Result<std::optional<SubAcquirer>>::withValue(value);
+  }
+  inline Result_std__optional_SubAcquirer__ create_Result_std__optional_SubAcquirer__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<SubAcquirer>>::withError(error);
+  }
+  
+  // pragma MARK: Result<UserData>
+  using Result_UserData_ = Result<UserData>;
+  inline Result_UserData_ create_Result_UserData_(const UserData& value) noexcept {
+    return Result<UserData>::withValue(value);
+  }
+  inline Result_UserData_ create_Result_UserData_(const std::exception_ptr& error) noexcept {
+    return Result<UserData>::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);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<double, CustomError>>>>
+  using Result_std__shared_ptr_Promise_std__variant_double__CustomError____ = Result<std::shared_ptr<Promise<std::variant<double, CustomError>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_double__CustomError____ create_Result_std__shared_ptr_Promise_std__variant_double__CustomError____(const std::shared_ptr<Promise<std::variant<double, CustomError>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<double, CustomError>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__variant_double__CustomError____ create_Result_std__shared_ptr_Promise_std__variant_double__CustomError____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<double, CustomError>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<CustomError>>
+  using Result_std__optional_CustomError__ = Result<std::optional<CustomError>>;
+  inline Result_std__optional_CustomError__ create_Result_std__optional_CustomError__(const std::optional<CustomError>& value) noexcept {
+    return Result<std::optional<CustomError>>::withValue(value);
+  }
+  inline Result_std__optional_CustomError__ create_Result_std__optional_CustomError__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<CustomError>>::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);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<CustomError, TransactionResult>>>>
+  using Result_std__shared_ptr_Promise_std__variant_CustomError__TransactionResult____ = Result<std::shared_ptr<Promise<std::variant<CustomError, TransactionResult>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_CustomError__TransactionResult____ create_Result_std__shared_ptr_Promise_std__variant_CustomError__TransactionResult____(const std::shared_ptr<Promise<std::variant<CustomError, TransactionResult>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<CustomError, TransactionResult>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__variant_CustomError__TransactionResult____ create_Result_std__shared_ptr_Promise_std__variant_CustomError__TransactionResult____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<CustomError, TransactionResult>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::variant<CustomError, TransactionResult>>
+  using Result_std__variant_CustomError__TransactionResult__ = Result<std::variant<CustomError, TransactionResult>>;
+  inline Result_std__variant_CustomError__TransactionResult__ create_Result_std__variant_CustomError__TransactionResult__(const std::variant<CustomError, TransactionResult>& value) noexcept {
+    return Result<std::variant<CustomError, TransactionResult>>::withValue(value);
+  }
+  inline Result_std__variant_CustomError__TransactionResult__ create_Result_std__variant_CustomError__TransactionResult__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<CustomError, TransactionResult>>::withError(error);
+  }
+
+} // namespace margelo::nitro::pospagseguro::bridge::swift